Datasets:

AISE-TUDelft

/

StackLessV2_LowLevel

like 0

Follow

AISE research lab at TU Delft 51

run-tests.lisp

cac-t-u-s_om-sharp/src/api/foreign-interface/ffi/CFFI/tests/run-tests.lisp

;;;; -*- Mode: lisp; indent-tabs-mode: nil -*- ;;; ;;; run-tests.lisp --- Simple script to run the unit tests. ;;; ;;; Copyright (C) 2005-2006, James Bielman <[email protected]> ;;; ;;; Permission is hereby granted, free of charge, to any person ;;; obtaining a copy of this software and associated documentation ;;; files (the "Software"), to deal in the Software without ;;; restriction, including without limitation the rights to use, copy, ;;; modify, merge, publish, distribute, sublicense, and/or sell copies ;;; of the Software, and to permit persons to whom the Software is ;;; furnished to do so, subject to the following conditions: ;;; ;;; The above copyright notice and this permission notice shall be ;;; included in all copies or substantial portions of the Software. ;;; ;;; THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, ;;; EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF ;;; MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND ;;; NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT ;;; HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, ;;; WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, ;;; OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER ;;; DEALINGS IN THE SOFTWARE. ;;; (format t "~&;;; -------- Running tests in ~A --------~%" (lisp-implementation-type)) (setf *load-verbose* nil *compile-verbose* nil *compile-print* nil) #+cmu (setf ext:*gc-verbose* nil) #+(and (not asdf) (or sbcl openmcl ecl mkcl)) (require "asdf") (asdf:operate 'asdf:load-op 'cffi-tests :verbose nil) (asdf:operate 'asdf:test-op 'cffi-tests) (in-package #:cl-user) (terpri) (force-output) #-allegro (quit) #+allegro (exit)

Common Lisp

.lisp

cac-t-u-s/om-sharp

GPL-3.0

9/19/2024, 11:25:22 AM (Europe/Amsterdam)

1192ca974f924a6e88c87a5d8c7d92326eb908b7278af2b47da12b1160df963b

bindings.lisp

cac-t-u-s_om-sharp/src/api/foreign-interface/ffi/CFFI/tests/bindings.lisp

;;;; -*- Mode: lisp; indent-tabs-mode: nil -*- ;;; ;;; libtest.lisp --- Setup CFFI bindings for libtest. ;;; ;;; Copyright (C) 2005-2007, Luis Oliveira <loliveira(@)common-lisp.net> ;;; ;;; Permission is hereby granted, free of charge, to any person ;;; obtaining a copy of this software and associated documentation ;;; files (the "Software"), to deal in the Software without ;;; restriction, including without limitation the rights to use, copy, ;;; modify, merge, publish, distribute, sublicense, and/or sell copies ;;; of the Software, and to permit persons to whom the Software is ;;; furnished to do so, subject to the following conditions: ;;; ;;; The above copyright notice and this permission notice shall be ;;; included in all copies or substantial portions of the Software. ;;; ;;; THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, ;;; EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF ;;; MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND ;;; NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT ;;; HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, ;;; WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, ;;; OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER ;;; DEALINGS IN THE SOFTWARE. ;;; (in-package #:cffi-tests) (define-foreign-library (libtest :type :test) (:darwin (:or "libtest.dylib" "libtest32.dylib")) (:unix (:or "libtest.so" "libtest32.so")) (:windows "libtest.dll") (t (:default "libtest"))) (define-foreign-library (libtest2 :type :test) (:darwin (:or "libtest2.dylib" "libtest2_32.dylib")) (:unix (:or "libtest2.so" "libtest2_32.so")) (t (:default "libtest2"))) (define-foreign-library (libfsbv :type :test) (:darwin (:or "libfsbv.dylib" "libfsbv32.dylib")) (:unix (:or "libfsbv.so" "libfsbv_32.so")) (:windows "libfsbv.dll") (t (:default "libfsbv"))) (define-foreign-library libc (:windows "msvcrt.dll")) (define-foreign-library libm #+(and lispworks darwin) ; not sure why the full path is necessary (:darwin "/usr/lib/libm.dylib") (t (:default "libm"))) (defun call-within-new-thread (fn &rest args) (let (result error (cv (bordeaux-threads:make-condition-variable)) (lock (bordeaux-threads:make-lock))) (bordeaux-threads:with-lock-held (lock) (bordeaux-threads:make-thread (lambda () (multiple-value-setq (result error) (ignore-errors (apply fn args))) (bordeaux-threads:with-lock-held (lock) (bordeaux-threads:condition-notify cv)))) (bordeaux-threads:condition-wait cv lock) (values result error)))) ;;; As of OSX 10.6.6, loading CoreFoundation on something other than ;;; the initial thread results in a crash. (deftest load-core-foundation (progn #+bordeaux-threads (call-within-new-thread 'load-foreign-library '(:framework "CoreFoundation")) t) t) ;;; Return the directory containing the source when compiling or ;;; loading this file. We don't use *LOAD-TRUENAME* because the fasl ;;; file may be in a different directory than the source with certain ;;; ASDF extensions loaded. (defun load-directory () (let ((here #.(or *compile-file-truename* *load-truename*))) (make-pathname :name nil :type nil :version nil :defaults here))) (defun load-test-libraries () (let ((*foreign-library-directories* (list (load-directory)))) (load-foreign-library 'libtest) (load-foreign-library 'libtest2) #+fsbv (load-foreign-library 'libfsbv) (load-foreign-library 'libc) #+(or abcl lispworks) (load-foreign-library 'libm))) #-(:and :ecl (:not :dffi)) (load-test-libraries) #+(:and :ecl (:not :dffi)) (ffi:load-foreign-library #.(make-pathname :name "libtest" :type "so" :defaults (or *compile-file-truename* *load-truename*))) ;;; check libtest version (defparameter *required-dll-version* "20120107") (defcvar "dll_version" :string) (unless (string= *dll-version* *required-dll-version*) (error "version check failed: expected ~s but libtest reports ~s" *required-dll-version* *dll-version*)) ;;; The maximum and minimum values for single and double precision C ;;; floating point values, which may be quite different from the ;;; corresponding Lisp versions. (defcvar "float_max" :float) (defcvar "float_min" :float) (defcvar "double_max" :double) (defcvar "double_min" :double) (defun run-cffi-tests (&key (compiled nil)) (let ((regression-test::*compile-tests* compiled) (*package* (find-package '#:cffi-tests))) (format t "~&;;; running tests (~Acompiled)" (if compiled "" "un")) (do-tests))) (defmacro expecting-error (&body body) `(handler-case (progn ,@body :no-error) (error () :error)))

Common Lisp

.lisp

cac-t-u-s/om-sharp

GPL-3.0

9/19/2024, 11:25:22 AM (Europe/Amsterdam)

2710bfe4a1f909ba6b9bc155be09f056666290417bdcbfefb55dc3bdb13c2880

misc-types.lisp

cac-t-u-s_om-sharp/src/api/foreign-interface/ffi/CFFI/tests/misc-types.lisp

;;;; -*- Mode: lisp; indent-tabs-mode: nil -*- ;;; ;;; misc-types.lisp --- Various tests on the type system. ;;; ;;; Copyright (C) 2005-2006, Luis Oliveira <loliveira(@)common-lisp.net> ;;; ;;; Permission is hereby granted, free of charge, to any person ;;; obtaining a copy of this software and associated documentation ;;; files (the "Software"), to deal in the Software without ;;; restriction, including without limitation the rights to use, copy, ;;; modify, merge, publish, distribute, sublicense, and/or sell copies ;;; of the Software, and to permit persons to whom the Software is ;;; furnished to do so, subject to the following conditions: ;;; ;;; The above copyright notice and this permission notice shall be ;;; included in all copies or substantial portions of the Software. ;;; ;;; THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, ;;; EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF ;;; MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND ;;; NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT ;;; HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, ;;; WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, ;;; OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER ;;; DEALINGS IN THE SOFTWARE. ;;; (in-package #:cffi-tests) (defcfun ("my_strdup" strdup) :string+ptr (str :string)) (defcfun ("my_strfree" strfree) :void (str :pointer)) (deftest misc-types.string+ptr (destructuring-bind (string pointer) (strdup "foo") (strfree pointer) string) "foo") #-(and) (deftest misc-types.string+ptr.ub8 (destructuring-bind (string pointer) (strdup (make-array 3 :element-type '(unsigned-byte 8) :initial-contents (map 'list #'char-code "foo"))) (strfree pointer) string) "foo") #-(and) (deftest misc-types.string.ub8.1 (let ((array (make-array 7 :element-type '(unsigned-byte 8) :initial-contents '(84 117 114 97 110 103 97)))) (with-foreign-string (foreign-string array) (foreign-string-to-lisp foreign-string))) "Turanga") #-(and) (deftest misc-types.string.ub8.2 (let ((str (foreign-string-alloc (make-array 7 :element-type '(unsigned-byte 8) :initial-contents '(84 117 114 97 110 103 97))))) (prog1 (foreign-string-to-lisp str) (foreign-string-free str))) "Turanga") (defcfun "equalequal" :boolean (a (:boolean :int)) (b (:boolean :unsigned-int))) (defcfun "bool_and" (:boolean :char) (a (:boolean :unsigned-char)) (b (:boolean :char))) (defcfun "bool_xor" (:boolean :unsigned-long) (a (:boolean :long)) (b (:boolean :unsigned-long))) (deftest misc-types.boolean.1 (list (equalequal nil nil) (equalequal t t) (equalequal t 23) (bool-and 'a 'b) (bool-and "foo" nil) (bool-xor t nil) (bool-xor nil nil)) (t t t t nil t nil)) ;;; Regression test: boolean type only worked with canonicalized ;;; built-in integer types. Should work for any type that canonicalizes ;;; to a built-in integer type. (defctype int-for-bool :int) (defcfun ("equalequal" equalequal2) :boolean (a (:boolean int-for-bool)) (b (:boolean :uint))) (deftest misc-types.boolean.2 (equalequal2 nil t) nil) (defctype my-string :string+ptr) (defun funkify (str) (concatenate 'string "MORE " (string-upcase str))) (defun 3rd-person (value) (list (concatenate 'string "Strdup says: " (first value)) (second value))) ;; (defctype funky-string ;; (:wrapper my-string ;; :to-c #'funkify ;; :from-c (lambda (value) ;; (list ;; (concatenate 'string "Strdup says: " ;; (first value)) ;; (second value)))) ;; "A useful type.") (defctype funky-string (:wrapper my-string :to-c funkify :from-c 3rd-person)) (defcfun ("my_strdup" funky-strdup) funky-string (str funky-string)) (deftest misc-types.wrapper (destructuring-bind (string ptr) (funky-strdup "code") (strfree ptr) string) "Strdup says: MORE CODE") (deftest misc-types.sized-ints (mapcar #'foreign-type-size '(:int8 :uint8 :int16 :uint16 :int32 :uint32 :int64 :uint64)) (1 1 2 2 4 4 8 8)) (define-foreign-type error-error () () (:actual-type :int) (:simple-parser error-error)) (defmethod translate-to-foreign (value (type error-error)) (declare (ignore value)) (error "translate-to-foreign invoked.")) (defmethod translate-from-foreign (value (type error-error)) (declare (ignore value)) (error "translate-from-foreign invoked.")) (eval-when (:load-toplevel :compile-toplevel :execute) (defmethod expand-to-foreign (value (type error-error)) value) (defmethod expand-from-foreign (value (type error-error)) value)) (defcfun ("abs" expand-abs) error-error (n error-error)) (defcvar ("var_int" *expand-var-int*) error-error) (defcfun ("expect_int_sum" expand-expect-int-sum) :boolean (cb :pointer)) (defcallback expand-int-sum error-error ((x error-error) (y error-error)) (+ x y)) ;;; Ensure that macroexpansion-time translators are called where this ;;; is guaranteed (defcfun, defcvar, foreign-funcall and defcallback) (deftest misc-types.expand.1 (expand-abs -1) 1) #-cffi-sys::no-foreign-funcall (deftest misc-types.expand.2 (foreign-funcall "abs" error-error -1 error-error) 1) (deftest misc-types.expand.3 (let ((old (mem-ref (get-var-pointer '*expand-var-int*) :int))) (unwind-protect (progn (setf *expand-var-int* 42) *expand-var-int*) (setf (mem-ref (get-var-pointer '*expand-var-int*) :int) old))) 42) (deftest misc-types.expand.4 (expand-expect-int-sum (callback expand-int-sum)) t) (define-foreign-type translate-tracker () () (:actual-type :int) (:simple-parser translate-tracker)) (declaim (special .fto-called.)) (defmethod free-translated-object (value (type translate-tracker) param) (declare (ignore value param)) (setf .fto-called. t)) (define-foreign-type expand-tracker () () (:actual-type :int) (:simple-parser expand-tracker)) (defmethod free-translated-object (value (type expand-tracker) param) (declare (ignore value param)) (setf .fto-called. t)) (eval-when (:compile-toplevel :load-toplevel :execute) (defmethod expand-to-foreign (value (type expand-tracker)) (declare (ignore value)) (call-next-method))) (defcfun ("abs" ttracker-abs) :int (n translate-tracker)) (defcfun ("abs" etracker-abs) :int (n expand-tracker)) ;; free-translated-object must be called when there is no etf (deftest misc-types.expand.5 (let ((.fto-called. nil)) (ttracker-abs -1) .fto-called.) t) ;; free-translated-object must be called when there is an etf, but ;; they answer *runtime-translator-form* (deftest misc-types.expand.6 (let ((.fto-called. nil)) (etracker-abs -1) .fto-called.) t) (define-foreign-type misc-type.expand.7 () () (:actual-type :int) (:simple-parser misc-type.expand.7)) (defmethod translate-to-foreign (value (type misc-type.expand.7)) (values value 'second-value)) ;; Auxiliary function to test CONVERT-TO-FOREIGN's compiler macro. (defun misc-type.expand.7-aux () (convert-to-foreign "foo" 'misc-type.expand.7)) ;; Checking that expand-to-foreign doesn't ignore the second value of ;; translate-to-foreign. (deftest misc-type.expand.7 (misc-type.expand.7-aux) "foo" second-value) ;; Like MISC-TYPE.EXPAND.7 but doesn't depend on compiler macros ;; kicking in. (deftest misc-type.expand.8 (eval (expand-to-foreign "foo" (cffi::parse-type 'misc-type.expand.7))) "foo" second-value)

Common Lisp

.lisp

cac-t-u-s/om-sharp

GPL-3.0

9/19/2024, 11:25:22 AM (Europe/Amsterdam)

22c11c3ef6a35587940e052da05ad18222d113381445f35c6fcb2417f241cdc4

funcall.lisp

cac-t-u-s_om-sharp/src/api/foreign-interface/ffi/CFFI/tests/funcall.lisp

;;;; -*- Mode: lisp; indent-tabs-mode: nil -*- ;;; ;;; funcall.lisp --- Tests function calling. ;;; ;;; Copyright (C) 2005-2006, James Bielman <[email protected]> ;;; Copyright (C) 2005-2007, Luis Oliveira <[email protected]> ;;; ;;; Permission is hereby granted, free of charge, to any person ;;; obtaining a copy of this software and associated documentation ;;; files (the "Software"), to deal in the Software without ;;; restriction, including without limitation the rights to use, copy, ;;; modify, merge, publish, distribute, sublicense, and/or sell copies ;;; of the Software, and to permit persons to whom the Software is ;;; furnished to do so, subject to the following conditions: ;;; ;;; The above copyright notice and this permission notice shall be ;;; included in all copies or substantial portions of the Software. ;;; ;;; THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, ;;; EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF ;;; MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND ;;; NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT ;;; HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, ;;; WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, ;;; OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER ;;; DEALINGS IN THE SOFTWARE. ;;; (in-package #:cffi-tests) ;;;# Calling with Built-In C Types ;;; ;;; Tests calling standard C library functions both passing and ;;; returning each built-in type. ;;; Don't run these tests if the implementation does not support ;;; foreign-funcall. #-cffi-sys::no-foreign-funcall (progn (deftest funcall.char (foreign-funcall "toupper" :char (char-code #\a) :char) #.(char-code #\A)) (deftest funcall.int.1 (foreign-funcall "abs" :int -100 :int) 100) (defun funcall-abs (n) (foreign-funcall "abs" :int n :int)) ;;; regression test: lispworks's %foreign-funcall based on creating ;;; and caching foreign-funcallables at macro-expansion time. (deftest funcall.int.2 (funcall-abs -42) 42) (deftest funcall.long (foreign-funcall "labs" :long -131072 :long) 131072) #-cffi-sys::no-long-long (deftest funcall.long-long (foreign-funcall "my_llabs" :long-long -9223372036854775807 :long-long) 9223372036854775807) #-cffi-sys::no-long-long (deftest funcall.unsigned-long-long (let ((ullong-max (1- (expt 2 (* 8 (foreign-type-size :unsigned-long-long)))))) (eql ullong-max (foreign-funcall "ullong" :unsigned-long-long ullong-max :unsigned-long-long))) t) (deftest funcall.float (foreign-funcall "my_sqrtf" :float 16.0 :float) 4.0) (deftest funcall.double (foreign-funcall "sqrt" :double 36.0d0 :double) 6.0d0) #+(and scl long-float) (deftest funcall.long-double (foreign-funcall "sqrtl" :long-double 36.0l0 :long-double) 6.0l0) (deftest funcall.string.1 (foreign-funcall "strlen" :string "Hello" :int) 5) (deftest funcall.string.2 (with-foreign-pointer-as-string (s 100) (setf (mem-ref s :char) 0) (foreign-funcall "strcpy" :pointer s :string "Hello" :pointer) (foreign-funcall "strcat" :pointer s :string ", world!" :pointer)) "Hello, world!") (deftest funcall.string.3 (with-foreign-pointer (ptr 100) (lisp-string-to-foreign "Hello, " ptr 8) (foreign-funcall "strcat" :pointer ptr :string "world!" :string)) "Hello, world!") ;;;# Calling Varargs Functions ;; The CHAR argument must be passed as :INT because chars are promoted ;; to ints when passed as variable arguments. (deftest funcall.varargs.char (with-foreign-pointer-as-string (s 100) (setf (mem-ref s :char) 0) (foreign-funcall "sprintf" :pointer s :string "%c" :int 65 :int)) "A") (deftest funcall.varargs.int (with-foreign-pointer-as-string (s 100) (setf (mem-ref s :char) 0) (foreign-funcall "sprintf" :pointer s :string "%d" :int 1000 :int)) "1000") (deftest funcall.varargs.long (with-foreign-pointer-as-string (s 100) (setf (mem-ref s :char) 0) (foreign-funcall "sprintf" :pointer s :string "%ld" :long 131072 :int)) "131072") ;;; There is no FUNCALL.VARARGS.FLOAT as floats are promoted to double ;;; when passed as variable arguments. Currently this fails in SBCL ;;; and CMU CL on Darwin/ppc. (deftest funcall.varargs.double (with-foreign-pointer-as-string (s 100) (setf (mem-ref s :char) 0) (foreign-funcall "sprintf" :pointer s :string "%.2f" :double (coerce pi 'double-float) :int)) "3.14") #+(and scl long-float) (deftest funcall.varargs.long-double (with-foreign-pointer-as-string (s 100) (setf (mem-ref s :char) 0) (foreign-funcall "sprintf" :pointer s :string "%.2Lf" :long-double pi :int)) "3.14") (deftest funcall.varargs.string (with-foreign-pointer-as-string (s 100) (setf (mem-ref s :char) 0) (foreign-funcall "sprintf" :pointer s :string "%s, %s!" :string "Hello" :string "world" :int)) "Hello, world!") ;;; See DEFCFUN.DOUBLE26. (deftest funcall.double26 (foreign-funcall "sum_double26" :double 3.14d0 :double 3.14d0 :double 3.14d0 :double 3.14d0 :double 3.14d0 :double 3.14d0 :double 3.14d0 :double 3.14d0 :double 3.14d0 :double 3.14d0 :double 3.14d0 :double 3.14d0 :double 3.14d0 :double 3.14d0 :double 3.14d0 :double 3.14d0 :double 3.14d0 :double 3.14d0 :double 3.14d0 :double 3.14d0 :double 3.14d0 :double 3.14d0 :double 3.14d0 :double 3.14d0 :double 3.14d0 :double 3.14d0 :double) 81.64d0) ;;; See DEFCFUN.FLOAT26. (deftest funcall.float26 (foreign-funcall "sum_float26" :float 5.0 :float 5.0 :float 5.0 :float 5.0 :float 5.0 :float 5.0 :float 5.0 :float 5.0 :float 5.0 :float 5.0 :float 5.0 :float 5.0 :float 5.0 :float 5.0 :float 5.0 :float 5.0 :float 5.0 :float 5.0 :float 5.0 :float 5.0 :float 5.0 :float 5.0 :float 5.0 :float 5.0 :float 5.0 :float 5.0 :float) 130.0) ;;; Funcalling a pointer. (deftest funcall.f-s-p.1 (foreign-funcall-pointer (foreign-symbol-pointer "abs") nil :int -42 :int) 42) ;;;# Namespaces #-cffi-sys::flat-namespace (deftest funcall.namespace.1 (values (foreign-funcall ("ns_function" :library libtest) :boolean) (foreign-funcall ("ns_function" :library libtest2) :boolean)) t nil) ;;;# stdcall #+(and x86 windows (not cffi-sys::no-stdcall)) (deftest funcall.stdcall.1 (flet ((fun () (foreign-funcall ("stdcall_fun@12" :convention :stdcall) :int 1 :int 2 :int 3 :int))) (loop repeat 100 do (fun) finally (return (fun)))) 6) ;;; RT: NIL arguments are skipped (defvar *nil-skipped*) (define-foreign-type check-nil-skip-type () () (:actual-type :pointer) (:simple-parser check-nil-skip-type)) (defmethod expand-to-foreign (val (type check-nil-skip-type)) (declare (ignore val)) (setf *nil-skipped* nil) (null-pointer)) (deftest funcall.nil-skip (let ((*nil-skipped* t)) (compile nil '(lambda () (foreign-funcall "abs" check-nil-skip-type nil))) *nil-skipped*) nil) ;;; RT: CLISP returns NIL instead of a null-pointer (deftest funcall.pointer-not-nil (not (null (foreign-funcall "strchr" :string "" :int 1 :pointer))) t) ) ;; #-cffi-sys::no-foreign-funcall

Common Lisp

.lisp

cac-t-u-s/om-sharp

GPL-3.0

9/19/2024, 11:25:22 AM (Europe/Amsterdam)

e1a6b302b362777a77ef274123eee7403e0f7034fb6633817fc47cd22e64115c

misc.lisp

cac-t-u-s_om-sharp/src/api/foreign-interface/ffi/CFFI/tests/misc.lisp

;;;; -*- Mode: lisp; indent-tabs-mode: nil -*- ;;; ;;; misc.lisp --- Miscellaneous tests. ;;; ;;; Copyright (C) 2006, Luis Oliveira <[email protected]> ;;; ;;; Permission is hereby granted, free of charge, to any person ;;; obtaining a copy of this software and associated documentation ;;; files (the "Software"), to deal in the Software without ;;; restriction, including without limitation the rights to use, copy, ;;; modify, merge, publish, distribute, sublicense, and/or sell copies ;;; of the Software, and to permit persons to whom the Software is ;;; furnished to do so, subject to the following conditions: ;;; ;;; The above copyright notice and this permission notice shall be ;;; included in all copies or substantial portions of the Software. ;;; ;;; THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, ;;; EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF ;;; MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND ;;; NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT ;;; HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, ;;; WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, ;;; OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER ;;; DEALINGS IN THE SOFTWARE. ;;; (in-package #:cffi-tests) ;;;# foreign-symbol-pointer tests ;;; This might be useful for some libraries that compare function ;;; pointers. http://thread.gmane.org/gmane.lisp.cffi.devel/694 (defcfun "compare_against_abs" :boolean (p :pointer)) (deftest foreign-symbol-pointer.1 (compare-against-abs (foreign-symbol-pointer "abs")) t) (defcfun "compare_against_xpto_fun" :boolean (p :pointer)) (deftest foreign-symbol-pointer.2 (compare-against-xpto-fun (foreign-symbol-pointer "xpto_fun")) t) ;;;# Library tests ;;; ;;; Need to figure out a way to test this. CLISP, for instance, will ;;; automatically reopen the foreign-library when we call a foreign ;;; function so we can't test CLOSE-FOREIGN-LIBRARY this way. ;;; ;;; IIRC, GCC has some extensions to have code run when a library is ;;; loaded and stuff like that. That could work. #|| #-(and ecl (not dffi)) (deftest library.close.2 (unwind-protect (progn (close-foreign-library 'libtest) (ignore-errors (my-sqrtf 16.0))) (load-test-libraries)) nil) #-(or (and ecl (not dffi)) cffi-sys::flat-namespace cffi-sys::no-foreign-funcall) (deftest library.close.2 (unwind-protect (values (foreign-funcall ("ns_function" :library libtest) :boolean) (close-foreign-library 'libtest) (foreign-funcall "ns_function" :boolean) (close-foreign-library 'libtest2) (close-foreign-library 'libtest2) (ignore-errors (foreign-funcall "ns_function" :boolean))) (load-test-libraries)) t t nil t nil nil) ||# (deftest library.error.1 (handler-case (load-foreign-library "libdoesnotexistimsure") (load-foreign-library-error () 'error)) error) (define-foreign-library pseudo-library (t pseudo-library-spec)) ;;; RT: T clause was being handled as :T by FEATUREP. ;;; ;;; We might want to export (and clean up) the API used in this test ;;; when the need arises. (deftest library.t-clause (eq (cffi::foreign-library-spec (cffi::get-foreign-library 'pseudo-library)) 'pseudo-library-spec) t) ;;;# Shareable Byte Vector Tests #+ecl (mapc (lambda (x) (pushnew x rt::*expected-failures*)) '(shareable-vector.1 shareable-vector.2)) (deftest shareable-vector.1 (let ((vector (cffi-sys::make-shareable-byte-vector 5))) (cffi::with-pointer-to-vector-data (pointer vector) (strcpy pointer "xpto")) vector) #(120 112 116 111 0)) (deftest shareable-vector.2 (block nil (let ((vector (cffi-sys::make-shareable-byte-vector 5))) (cffi::with-pointer-to-vector-data (pointer vector) (strcpy pointer "xpto") (return vector)))) #(120 112 116 111 0))

Common Lisp

.lisp

cac-t-u-s/om-sharp

GPL-3.0

9/19/2024, 11:25:22 AM (Europe/Amsterdam)

342bf7a51a16e92fb32853efc0a8b9b1f604de83d4a1f569d4fcbf310d865c3f

union.lisp

cac-t-u-s_om-sharp/src/api/foreign-interface/ffi/CFFI/tests/union.lisp

;;;; -*- Mode: lisp; indent-tabs-mode: nil -*- ;;; ;;; union.lisp --- Tests on C unions. ;;; ;;; Copyright (C) 2005-2006, James Bielman <[email protected]> ;;; ;;; Permission is hereby granted, free of charge, to any person ;;; obtaining a copy of this software and associated documentation ;;; files (the "Software"), to deal in the Software without ;;; restriction, including without limitation the rights to use, copy, ;;; modify, merge, publish, distribute, sublicense, and/or sell copies ;;; of the Software, and to permit persons to whom the Software is ;;; furnished to do so, subject to the following conditions: ;;; ;;; The above copyright notice and this permission notice shall be ;;; included in all copies or substantial portions of the Software. ;;; ;;; THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, ;;; EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF ;;; MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND ;;; NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT ;;; HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, ;;; WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, ;;; OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER ;;; DEALINGS IN THE SOFTWARE. ;;; (in-package #:cffi-tests) (defcunion uint32-bytes (int-value :unsigned-int) (bytes :unsigned-char :count 4)) (defctype uint32-bytes (:union uint32-bytes)) (defun int-to-bytes (n) "Convert N to a list of bytes using a union." (with-foreign-object (obj 'uint32-bytes) (setf (foreign-slot-value obj 'uint32-bytes 'int-value) n) (loop for i from 0 below 4 collect (mem-aref (foreign-slot-value obj 'uint32-bytes 'bytes) :unsigned-char i)))) (deftest union.1 (let ((bytes (int-to-bytes #x12345678))) (cond ((equal bytes '(#x12 #x34 #x56 #x78)) t) ((equal bytes '(#x78 #x56 #x34 #x12)) t) (t bytes))) t)

Common Lisp

.lisp

cac-t-u-s/om-sharp

GPL-3.0

9/19/2024, 11:25:22 AM (Europe/Amsterdam)

b5efea02382a547703e4b9d309a391ac9ecdb2dada56976e0445818edf249b05

struct.lisp

cac-t-u-s_om-sharp/src/api/foreign-interface/ffi/CFFI/tests/struct.lisp

;;;; -*- Mode: lisp; indent-tabs-mode: nil -*- ;;; ;;; struct.lisp --- Foreign structure type tests. ;;; ;;; Copyright (C) 2005-2006, James Bielman <[email protected]> ;;; Copyright (C) 2005-2011, Luis Oliveira <[email protected]> ;;; ;;; Permission is hereby granted, free of charge, to any person ;;; obtaining a copy of this software and associated documentation ;;; files (the "Software"), to deal in the Software without ;;; restriction, including without limitation the rights to use, copy, ;;; modify, merge, publish, distribute, sublicense, and/or sell copies ;;; of the Software, and to permit persons to whom the Software is ;;; furnished to do so, subject to the following conditions: ;;; ;;; The above copyright notice and this permission notice shall be ;;; included in all copies or substantial portions of the Software. ;;; ;;; THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, ;;; EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF ;;; MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND ;;; NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT ;;; HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, ;;; WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, ;;; OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER ;;; DEALINGS IN THE SOFTWARE. ;;; (in-package #:cffi-tests) (defcstruct timeval (tv-secs :long) (tv-usecs :long)) (defparameter *timeval-size* (* 2 (max (foreign-type-size :long) (foreign-type-alignment :long)))) ;;;# Basic Structure Tests (deftest struct.1 (- (foreign-type-size 'timeval) *timeval-size*) 0) (deftest struct.2 (with-foreign-object (tv 'timeval) (setf (foreign-slot-value tv 'timeval 'tv-secs) 0) (setf (foreign-slot-value tv 'timeval 'tv-usecs) 1) (values (foreign-slot-value tv 'timeval 'tv-secs) (foreign-slot-value tv 'timeval 'tv-usecs))) 0 1) (deftest struct.3 (with-foreign-object (tv 'timeval) (with-foreign-slots ((tv-secs tv-usecs) tv timeval) (setf tv-secs 100 tv-usecs 200) (values tv-secs tv-usecs))) 100 200) ;; regression test: accessing a struct through a typedef (defctype xpto (:struct timeval)) (deftest struct.4 (with-foreign-object (tv 'xpto) (setf (foreign-slot-value tv 'xpto 'tv-usecs) 1) (values (foreign-slot-value tv 'xpto 'tv-usecs) (foreign-slot-value tv 'timeval 'tv-usecs))) 1 1) (deftest struct.names (sort (foreign-slot-names 'xpto) #'< :key (lambda (x) (foreign-slot-offset 'xpto x))) (tv-secs tv-usecs)) ;; regression test: compiler macro not quoting the type in the ;; resulting mem-ref form. The compiler macro on foreign-slot-value ;; is not guaranteed to be expanded though. (defctype my-int :int) (defcstruct s5 (a my-int)) (deftest struct.5 (with-foreign-object (s 's5) (setf (foreign-slot-value s 's5 'a) 42) (foreign-slot-value s 's5 'a)) 42) ;;;# Structs with type translators (defcstruct struct-string (s :string)) (deftest struct.string.1 (with-foreign-object (ptr 'struct-string) (with-foreign-slots ((s) ptr struct-string) (setf s "So long and thanks for all the fish!") s)) "So long and thanks for all the fish!") (deftest struct.string.2 (with-foreign-object (ptr 'struct-string) (setf (foreign-slot-value ptr 'struct-string 's) "Cha") (foreign-slot-value ptr 'struct-string 's)) "Cha") ;;;# Structure Alignment Tests ;;; ;;; See libtest.c and types.lisp for some comments about alignments. (defcstruct s-ch (a-char :char)) (defctype s-ch (:struct s-ch)) (defcstruct s-s-ch (another-char :char) (a-s-ch s-ch)) (defctype s-s-ch (:struct s-s-ch)) (defcvar "the_s_s_ch" s-s-ch) (deftest struct.alignment.1 (list 'a-char (foreign-slot-value (foreign-slot-pointer *the-s-s-ch* 's-s-ch 'a-s-ch) 's-ch 'a-char) 'another-char (foreign-slot-value *the-s-s-ch* 's-s-ch 'another-char)) (a-char 1 another-char 2)) (defcstruct s-short (a-char :char) (another-char :char) (a-short :short)) (defctype s-short (:struct s-short)) (defcstruct s-s-short (yet-another-char :char) (a-s-short s-short)) (defctype s-s-short (:struct s-s-short)) (defcvar "the_s_s_short" s-s-short) (deftest struct.alignment.2 (with-foreign-slots ((yet-another-char a-s-short) *the-s-s-short* s-s-short) (with-foreign-slots ((a-char another-char a-short) a-s-short s-short) (list 'a-char a-char 'another-char another-char 'a-short a-short 'yet-another-char yet-another-char))) (a-char 1 another-char 2 a-short 3 yet-another-char 4)) (defcstruct s-double (a-char :char) (a-double :double) (another-char :char)) (defctype s-double (:struct s-double)) (defcstruct s-s-double (yet-another-char :char) (a-s-double s-double) (a-short :short)) (defctype s-s-double (:struct s-s-double)) (defcvar "the_s_s_double" s-s-double) (deftest struct.alignment.3 (with-foreign-slots ((yet-another-char a-s-double a-short) *the-s-s-double* s-s-double) (with-foreign-slots ((a-char a-double another-char) a-s-double s-double) (list 'a-char a-char 'a-double a-double 'another-char another-char 'yet-another-char yet-another-char 'a-short a-short))) (a-char 1 a-double 2.0d0 another-char 3 yet-another-char 4 a-short 5)) (defcstruct s-s-s-double (another-short :short) (a-s-s-double s-s-double) (last-char :char)) (defctype s-s-s-double (:struct s-s-s-double)) (defcvar "the_s_s_s_double" s-s-s-double) (deftest struct.alignment.4 (with-foreign-slots ((another-short a-s-s-double last-char) *the-s-s-s-double* s-s-s-double) (with-foreign-slots ((yet-another-char a-s-double a-short) a-s-s-double s-s-double) (with-foreign-slots ((a-char a-double another-char) a-s-double s-double) (list 'a-char a-char 'a-double a-double 'another-char another-char 'yet-another-char yet-another-char 'a-short a-short 'another-short another-short 'last-char last-char)))) (a-char 1 a-double 2.0d0 another-char 3 yet-another-char 4 a-short 5 another-short 6 last-char 7)) (defcstruct s-double2 (a-double :double) (a-short :short)) (defctype s-double2 (:struct s-double2)) (defcstruct s-s-double2 (a-char :char) (a-s-double2 s-double2) (another-short :short)) (defctype s-s-double2 (:struct s-s-double2)) (defcvar "the_s_s_double2" s-s-double2) (deftest struct.alignment.5 (with-foreign-slots ((a-char a-s-double2 another-short) *the-s-s-double2* s-s-double2) (with-foreign-slots ((a-double a-short) a-s-double2 s-double2) (list 'a-double a-double 'a-short a-short 'a-char a-char 'another-short another-short))) (a-double 1.0d0 a-short 2 a-char 3 another-short 4)) (defcstruct s-long-long (a-long-long :long-long) (a-short :short)) (defctype s-long-long (:struct s-long-long)) (defcstruct s-s-long-long (a-char :char) (a-s-long-long s-long-long) (another-short :short)) (defctype s-s-long-long (:struct s-s-long-long)) (defcvar "the_s_s_long_long" s-s-long-long) (deftest struct.alignment.6 (with-foreign-slots ((a-char a-s-long-long another-short) *the-s-s-long-long* s-s-long-long) (with-foreign-slots ((a-long-long a-short) a-s-long-long s-long-long) (list 'a-long-long a-long-long 'a-short a-short 'a-char a-char 'another-short another-short))) (a-long-long 1 a-short 2 a-char 3 another-short 4)) (defcstruct s-s-double3 (a-s-double2 s-double2) (another-short :short)) (defctype s-s-double3 (:struct s-s-double3)) (defcstruct s-s-s-double3 (a-s-s-double3 s-s-double3) (a-char :char)) (defctype s-s-s-double3 (:struct s-s-s-double3)) (defcvar "the_s_s_s_double3" s-s-s-double3) (deftest struct.alignment.7 (with-foreign-slots ((a-s-s-double3 a-char) *the-s-s-s-double3* s-s-s-double3) (with-foreign-slots ((a-s-double2 another-short) a-s-s-double3 s-s-double3) (with-foreign-slots ((a-double a-short) a-s-double2 s-double2) (list 'a-double a-double 'a-short a-short 'another-short another-short 'a-char a-char)))) (a-double 1.0d0 a-short 2 another-short 3 a-char 4)) (defcstruct empty-struct) (defctype empty-struct (:struct empty-struct)) (defcstruct with-empty-struct (foo empty-struct) (an-int :int)) ;; commented out this test because an empty struct is not valid/standard C ;; left the struct declarations anyway because they should be handled ;; gracefuly anyway. ; (defcvar "the_with_empty_struct" with-empty-struct) ; ; (deftest struct.alignment.5 ; (with-foreign-slots ((foo an-int) *the-with-empty-struct* with-empty-struct) ; an-int) ; 42) ;; regression test, setf-ing nested foreign-slot-value forms ;; the setf expander used to return a bogus getter (defcstruct s1 (an-int :int)) (defctype s1 (:struct s1)) (defcstruct s2 (an-s1 s1)) (defctype s2 (:struct s2)) (deftest struct.nested-setf (with-foreign-object (an-s2 's2) (setf (foreign-slot-value (foreign-slot-value an-s2 's2 'an-s1) 's1 'an-int) 1984) (foreign-slot-value (foreign-slot-value an-s2 's2 'an-s1) 's1 'an-int)) 1984) ;; regression test, some Lisps were returning 4 instead of 8 for ;; (foreign-type-alignment :unsigned-long-long) on darwin/ppc32 (defcstruct s-unsigned-long-long (an-unsigned-long-long :unsigned-long-long) (a-short :short)) (defctype s-unsigned-long-long (:struct s-unsigned-long-long)) (defcstruct s-s-unsigned-long-long (a-char :char) (a-s-unsigned-long-long s-unsigned-long-long) (another-short :short)) (defctype s-s-unsigned-long-long (:struct s-s-unsigned-long-long)) (defcvar "the_s_s_unsigned_long_long" s-s-unsigned-long-long) (deftest struct.alignment.8 (with-foreign-slots ((a-char a-s-unsigned-long-long another-short) *the-s-s-unsigned-long-long* s-s-unsigned-long-long) (with-foreign-slots ((an-unsigned-long-long a-short) a-s-unsigned-long-long s-unsigned-long-long) (list 'an-unsigned-long-long an-unsigned-long-long 'a-short a-short 'a-char a-char 'another-short another-short))) (an-unsigned-long-long 1 a-short 2 a-char 3 another-short 4)) ;;;# C Struct Wrappers (define-c-struct-wrapper timeval ()) (define-c-struct-wrapper (timeval2 (:struct timeval)) () (tv-secs)) (defmacro with-example-timeval (var &body body) `(with-foreign-object (,var 'timeval) (with-foreign-slots ((tv-secs tv-usecs) ,var timeval) (setf tv-secs 42 tv-usecs 1984) ,@body))) (deftest struct-wrapper.1 (with-example-timeval ptr (let ((obj (make-instance 'timeval :pointer ptr))) (values (timeval-tv-secs obj) (timeval-tv-usecs obj)))) 42 1984) (deftest struct-wrapper.2 (with-example-timeval ptr (let ((obj (make-instance 'timeval2 :pointer ptr))) (timeval2-tv-secs obj))) 42) ;;;# Structures as Values (defcstruct (struct-pair :class pair) (a :int) (b :int)) (defctype struct-pair-typedef1 (:struct struct-pair)) (defctype struct-pair-typedef2 (:pointer (:struct struct-pair))) (deftest struct.unparse.1 (mapcar (alexandria:compose #'cffi::unparse-type #'cffi::parse-type) '(struct-pair (:struct struct-pair) struct-pair-typedef1 struct-pair-typedef2)) (struct-pair (:struct struct-pair) struct-pair-typedef1 struct-pair-typedef2)) (deftest struct.canonicalize.1 (mapcar #'cffi::canonicalize-foreign-type '(struct-pair (:struct struct-pair) struct-pair-typedef1 struct-pair-typedef2)) (:pointer (:struct struct-pair) (:struct struct-pair) :pointer)) (deftest struct.canonicalize.2 (mapcar #'cffi::canonicalize-foreign-type '(struct-pair (:struct struct-pair) struct-pair-typedef1 struct-pair-typedef2)) (:pointer (:struct struct-pair) (:struct struct-pair) :pointer)) (defmethod translate-from-foreign (pointer (type pair)) (with-foreign-slots ((a b) pointer (:struct struct-pair)) (cons a b))) (defmethod translate-into-foreign-memory (object (type pair) pointer) (with-foreign-slots ((a b) pointer (:struct struct-pair)) (setf a (car object) b (cdr object)))) (defmethod translate-to-foreign (object (type pair)) (let ((p (foreign-alloc '(:struct struct-pair)))) (translate-into-foreign-memory object type p) (values p t))) (defmethod free-translated-object (pointer (type pair) freep) (when freep (foreign-free pointer))) (deftest struct-values.translation.1 (multiple-value-bind (p freep) (convert-to-foreign '(1 . 2) 'struct-pair) (assert freep) (unwind-protect (convert-from-foreign p 'struct-pair) (free-converted-object p 'struct-pair freep))) (1 . 2)) (defcfun "pair_pointer_sum" :int (p (:pointer (:struct struct-pair)))) #+#:pointer-translation-not-yet-implemented (deftest struct-values.translation.2 (pair-pointer-sum '(1 . 2)) 3) ;;; should the return type be something along the lines of ;;; (:pointer (:struct pair) :free t)? ;;; LMH: error on ":free t" option? (defcfun "alloc_pair" (:pointer (:struct struct-pair)) (a :int) (b :int)) ;; bogus: doesn't free() pointer. #+#:pointer-translation-not-yet-implemented (deftest struct-values.translation.3 (alloc-pair 1 2) (1 . 2)) (deftest struct-values.translation.mem-ref.1 (with-foreign-object (p '(:struct struct-pair)) (setf (mem-ref p '(:struct struct-pair)) '(1 . 2)) (with-foreign-slots ((a b) p (:struct struct-pair)) (values (mem-ref p '(:struct struct-pair)) a b))) (1 . 2) 1 2) (deftest struct-values.translation.mem-aref.1 (with-foreign-object (p '(:struct struct-pair) 2) (setf (mem-aref p '(:struct struct-pair) 0) '(1 . 2) (mem-aref p '(:struct struct-pair) 1) '(3 . 4)) (values (mem-aref p '(:struct struct-pair) 0) (mem-aref p '(:struct struct-pair) 1))) (1 . 2) (3 . 4)) (defcstruct (struct-pair-default-translate :class pair-default) (a :int) (b :int)) (deftest struct-values-default.translation.mem-ref.1 (with-foreign-object (p '(:struct struct-pair-default-translate)) (setf (mem-ref p '(:struct struct-pair-default-translate)) '(a 1 b 2)) (with-foreign-slots ((a b) p (:struct struct-pair-default-translate)) (let ((plist (mem-ref p '(:struct struct-pair-default-translate)))) (values (getf plist 'a) (getf plist 'b) a b)))) 1 2 1 2) (defcstruct (struct-pair+double :class pair+double) (pr (:struct struct-pair-default-translate)) (dbl :double)) (deftest struct-values-default.translation.mem-ref.2 (with-foreign-object (p '(:struct struct-pair+double)) (setf (mem-ref p '(:struct struct-pair+double)) '(pr (a 4 b 5) dbl 2.5d0)) (with-foreign-slots ((pr dbl) p (:struct struct-pair+double)) (let ((plist (mem-ref p '(:struct struct-pair+double)))) (values (getf (getf plist 'pr) 'a) (getf (getf plist 'pr) 'b) (getf plist 'dbl))))) 4 5 2.5d0) (defcstruct (struct-pair+1 :class pair+1) (p (:pointer (:struct struct-pair))) (c :int)) (defctype struct-pair+1 (:struct struct-pair+1)) (defmethod translate-from-foreign (pointer (type pair+1)) (with-foreign-slots ((p c) pointer struct-pair+1) (cons p c))) (defmethod translate-into-foreign-memory (object (type pair+1) pointer) (with-foreign-slots ((c) pointer struct-pair+1) (convert-into-foreign-memory (car object) 'struct-pair (foreign-slot-pointer pointer 'struct-pair+1 'p)) (setf c (cdr object)))) (defmethod translate-to-foreign (object (type pair+1)) (let ((p (foreign-alloc 'struct-pair+1))) (translate-into-foreign-memory object type p) (values p t))) (defmethod free-translated-object (pointer (type pair+1) freep) (when freep (foreign-free pointer))) #+#:pointer-translation-not-yet-implemented (deftest struct-values.translation.ppo.1 (multiple-value-bind (p freep) (convert-to-foreign '((1 . 2) . 3) 'struct-pair+1) (assert freep) (unwind-protect (convert-from-foreign p 'struct-pair+1) (free-converted-object p 'struct-pair+1 freep))) ((1 . 2) . 3)) #+#:unimplemented (defcfun "pair_plus_one_sum" :int (p (:struct pair+1))) (defcfun "pair_plus_one_pointer_sum" :int (p (:pointer (:struct struct-pair+1)))) #+#:pointer-translation-not-yet-implemented (deftest struct-values.translation.ppo.2 (pair-plus-one-pointer-sum '((1 . 2) . 3)) 6) #+#:unimplemented (defcfun "make_pair_plus_one" (:struct pair+1) (a :int) (b :int) (c :int)) (defcfun "alloc_pair_plus_one" struct-pair+1 (a :int) (b :int) (c :int)) ;; bogus: doesn't free() pointer. #+#:pointer-translation-not-yet-implemented (deftest struct-values.translation.ppo.3 (alloc-pair-plus-one 1 2 3) ((1 . 2) . 3)) #+#:unimplemented (defcfun "pair_sum" :int (p (:struct pair))) #+#:unimplemented (defcfun "make_pair" (:struct pair) (a :int) (b :int)) #|| ; TODO: load cffi-libffi for these tests to work. (deftest struct-values.fn.1 (with-foreign-object (p '(:struct pair)) (with-foreign-slots ((a b) p (:struct pair)) (setf a -1 b 2) (pair-sum p))) 1) (deftest struct-values.fn.2 (pair-sum '(3 . 5)) 8) (deftest struct-values.fn.3 (with-foreign-object (p '(:struct pair)) (make-pair 7 11 :result-pointer p) (with-foreign-slots ((a b) p (:struct pair)) (cons a b))) (7 . 11)) (deftest struct-values.fn.4 (make-pair 13 17) (13 . 17)) ||# (defcstruct single-byte-struct (a :uint8)) (deftest bare-struct-types.1 (eql (foreign-type-size 'single-byte-struct) (foreign-type-size '(:struct single-byte-struct))) t) (defctype single-byte-struct-alias (:struct single-byte-struct)) (deftest bare-struct-types.2 (eql (foreign-type-size 'single-byte-struct-alias) (foreign-type-size '(:struct single-byte-struct))) t) ;;; Old-style access to inner structure fields. (defcstruct inner-struct (x :int)) (defcstruct old-style-outer (inner inner-struct)) (defcstruct new-style-outer (inner (:struct inner-struct))) (deftest old-style-struct-access (with-foreign-object (s '(:struct old-style-outer)) (let ((inner-ptr (foreign-slot-pointer s 'old-style-outer 'inner))) (setf (foreign-slot-value inner-ptr 'inner-struct 'x) 42)) (assert (pointerp (foreign-slot-value s 'old-style-outer 'inner))) (foreign-slot-value (foreign-slot-value s 'old-style-outer 'inner) 'inner-struct 'x)) 42) (deftest new-style-struct-access (with-foreign-object (s '(:struct new-style-outer)) (let ((inner-ptr (foreign-slot-pointer s 'new-style-outer 'inner))) (setf (foreign-slot-value inner-ptr 'inner-struct 'x) 42)) (foreign-slot-value s 'new-style-outer 'inner)) (x 42))

Common Lisp

.lisp

cac-t-u-s/om-sharp

GPL-3.0

9/19/2024, 11:25:22 AM (Europe/Amsterdam)

90e3f3b639dbeca62ab580ef44d421cf086c4b2e4a02be0d2a8e4e1e8976575b

cstruct.lisp

cac-t-u-s_om-sharp/src/api/foreign-interface/ffi/CFFI/libffi/cstruct.lisp

;;;; -*- Mode: lisp; indent-tabs-mode: nil -*- ;;; ;;; cstruct.lisp --- Hook to defcstruct ;;; ;;; Copyright (C) 2009, 2010, 2011 Liam Healy <[email protected]> ;;; ;;; Permission is hereby granted, free of charge, to any person ;;; obtaining a copy of this software and associated documentation ;;; files (the "Software"), to deal in the Software without ;;; restriction, including without limitation the rights to use, copy, ;;; modify, merge, publish, distribute, sublicense, and/or sell copies ;;; of the Software, and to permit persons to whom the Software is ;;; furnished to do so, subject to the following conditions: ;;; ;;; The above copyright notice and this permission notice shall be ;;; included in all copies or substantial portions of the Software. ;;; ;;; THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, ;;; EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF ;;; MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND ;;; NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT ;;; HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, ;;; WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, ;;; OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER ;;; DEALINGS IN THE SOFTWARE. ;;; (in-package #:cffi) (defun slot-multiplicity (slot) (if (typep slot 'cffi::aggregate-struct-slot) (cffi::slot-count slot) 1)) (defun number-of-items (structure-type) "Total number of items in the foreign structure." (loop for val being the hash-value of (cffi::structure-slots structure-type) sum (slot-multiplicity val))) (defmethod libffi-type-pointer ((type foreign-struct-type)) (or (call-next-method) (set-libffi-type-pointer type (let* ((ptr (cffi:foreign-alloc '(:struct ffi-type))) (nitems (number-of-items type)) (type-pointer-array (cffi:foreign-alloc :pointer :count (1+ nitems)))) (loop for slot in (slots-in-order type) for ltp = (libffi-type-pointer (parse-type (slot-type slot))) with slot-counter = 0 do (if ltp (loop repeat (slot-multiplicity slot) do (setf (cffi:mem-aref type-pointer-array :pointer slot-counter) ltp) (incf slot-counter)) (error "Slot type ~a in foreign structure is unknown to libffi." (cffi::unparse-type (cffi::slot-type slot))))) (setf (cffi:mem-aref type-pointer-array :pointer nitems) (cffi:null-pointer) ;; The ffi-type (cffi:foreign-slot-value ptr '(:struct ffi-type) 'size) 0 (cffi:foreign-slot-value ptr '(:struct ffi-type) 'alignment) 0 (cffi:foreign-slot-value ptr '(:struct ffi-type) 'type) +type-struct+ (cffi:foreign-slot-value ptr '(:struct ffi-type) 'elements) type-pointer-array) ptr))))

Common Lisp

.lisp

cac-t-u-s/om-sharp

GPL-3.0

9/19/2024, 11:25:22 AM (Europe/Amsterdam)

3815f00f8c59989064f41dba6e2612b99076bff37bf1e86c7edc5d608fb6c136

built-in-types.lisp

cac-t-u-s_om-sharp/src/api/foreign-interface/ffi/CFFI/libffi/built-in-types.lisp

;;;; -*- Mode: lisp; indent-tabs-mode: nil -*- ;;; ;;; built-in-types.lisp -- Define libffi-type-pointers for built-in types and typedefs ;;; ;;; Copyright (C) 2011 Liam M. Healy <[email protected]> ;;; ;;; Permission is hereby granted, free of charge, to any person ;;; obtaining a copy of this software and associated documentation ;;; files (the "Software"), to deal in the Software without ;;; restriction, including without limitation the rights to use, copy, ;;; modify, merge, publish, distribute, sublicense, and/or sell copies ;;; of the Software, and to permit persons to whom the Software is ;;; furnished to do so, subject to the following conditions: ;;; ;;; The above copyright notice and this permission notice shall be ;;; included in all copies or substantial portions of the Software. ;;; ;;; THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, ;;; EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF ;;; MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND ;;; NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT ;;; HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, ;;; WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, ;;; OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER ;;; DEALINGS IN THE SOFTWARE. ;;; (in-package #:cffi) (defun set-libffi-type-pointer-for-built-in (type &optional (libffi-name type)) (set-libffi-type-pointer type (cffi:foreign-symbol-pointer (format nil "ffi_type_~(~a~)" libffi-name)))) ;;; Set the type pointers for non-integer built-in types (dolist (type (append cffi:*built-in-float-types* cffi:*other-builtin-types*)) (set-libffi-type-pointer-for-built-in type)) ;;; Set the type pointers for integer built-in types (dolist (type cffi:*built-in-integer-types*) (set-libffi-type-pointer-for-built-in type (format nil "~aint~d" (if (string-equal type "unsigned" :end1 (min 8 (length (string type)))) "u" "s") (* 8 (cffi:foreign-type-size type))))) ;;; Set the type pointer on demand for alias (e.g. typedef) types (defmethod libffi-type-pointer ((type cffi::foreign-type-alias)) (libffi-type-pointer (cffi::follow-typedefs type))) ;;; Luis thinks this is unnecessary; FOREIGN-ENUM inherits from FOREIGN-TYPE-ALIAS. #+(or) (defmethod libffi-type-pointer ((type cffi::foreign-enum)) (libffi-type-pointer (cffi::actual-type type)))

Common Lisp

.lisp

cac-t-u-s/om-sharp

GPL-3.0

9/19/2024, 11:25:22 AM (Europe/Amsterdam)

5106e8655a2842bac9c6d6bb45970d377777c56cacc030c5d56cd7ba3e69a7ad

libffi-unix.lisp

cac-t-u-s_om-sharp/src/api/foreign-interface/ffi/CFFI/libffi/libffi-unix.lisp

;;;; -*- Mode: lisp; indent-tabs-mode: nil -*- ;;; ;;; libffi-unix.lisp -- libffi CFFI-Grovel definitions for unix systems. ;;; ;;; Copyright (C) 2009, 2010, 2011 Liam M. Healy <[email protected]> ;;; ;;; Permission is hereby granted, free of charge, to any person ;;; obtaining a copy of this software and associated documentation ;;; files (the "Software"), to deal in the Software without ;;; restriction, including without limitation the rights to use, copy, ;;; modify, merge, publish, distribute, sublicense, and/or sell copies ;;; of the Software, and to permit persons to whom the Software is ;;; furnished to do so, subject to the following conditions: ;;; ;;; The above copyright notice and this permission notice shall be ;;; included in all copies or substantial portions of the Software. ;;; ;;; THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, ;;; EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF ;;; MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND ;;; NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT ;;; HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, ;;; WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, ;;; OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER ;;; DEALINGS IN THE SOFTWARE. ;;; (in-package #:cffi) #+linux (define "_GNU_SOURCE") ;; When installed through Mac Ports, libffi include files ;; will be found in /opt/local/include. #+darwin (cc-flags "-I/opt/local/include/") #+darwin (include "ffi/ffi.h") #-darwin (include "ffi.h") (cenum status ((:OK "FFI_OK")) ((:bad-typedef "FFI_BAD_TYPEDEF")) ((:bad-abi "FFI_BAD_ABI"))) (cenum abi ((:default-abi "FFI_DEFAULT_ABI")) ((:sysv "FFI_SYSV")) ((:unix64 "FFI_UNIX64"))) (ctype ffi-abi "ffi_abi") (ctype :sizet "size_t") (ctype ushort "unsigned short") (ctype unsigned "unsigned") (cstruct ffi-type "struct _ffi_type" (size "size" :type :sizet) (alignment "alignment" :type ushort) (type "type" :type ushort) (elements "elements" :type :pointer)) #| ;;; Will not compile ;;; error: invalid application of ‘sizeof’ to incomplete type ‘struct ffi_cif’ ;;; When structs are defined with the name at the end, apparently they ;;; are intended to be "opaque types". (cstruct ffi-cif "struct ffi_cif" (abi "abi" :type ffi-abi) (nargs "nargs" :type unsigned) (arg-types "arg_types" :type :pointer) (return-type "rtype" :type :pointer) (bytes "bytes" :type :unsigned) (flags "flags" :type :unsigned)) |# (constant (+type-void+ "FFI_TYPE_VOID")) (constant (+type-int+ "FFI_TYPE_INT")) (constant (+type-float+ "FFI_TYPE_FLOAT")) (constant (+type-double+ "FFI_TYPE_DOUBLE")) (constant (+type-longdouble+ "FFI_TYPE_LONGDOUBLE")) (constant (+type-uint8+ "FFI_TYPE_UINT8")) (constant (+type-sint8+ "FFI_TYPE_SINT8")) (constant (+type-uint16+ "FFI_TYPE_UINT16")) (constant (+type-sint16+ "FFI_TYPE_SINT16")) (constant (+type-uint32+ "FFI_TYPE_UINT32")) (constant (+type-sint32+ "FFI_TYPE_SINT32")) (constant (+type-uint64+ "FFI_TYPE_UINT64")) (constant (+type-sint64+ "FFI_TYPE_SINT64")) (constant (+type-struct+ "FFI_TYPE_STRUCT")) (constant (+type-pointer+ "FFI_TYPE_POINTER"))

Common Lisp

.lisp

cac-t-u-s/om-sharp

GPL-3.0

9/19/2024, 11:25:22 AM (Europe/Amsterdam)

e9ca875cae615ac0abfb0cd0949d61d0638b30efc3113aab71395ab864f85a9f

functions.lisp

cac-t-u-s_om-sharp/src/api/foreign-interface/ffi/CFFI/libffi/functions.lisp

;;;; -*- Mode: lisp; indent-tabs-mode: nil -*- ;;; ;;; functions.lisp -- Calling foreign functions ;;; ;;; Copyright (C) 2009, 2010, 2011 Liam M. Healy <[email protected]> ;;; ;;; Permission is hereby granted, free of charge, to any person ;;; obtaining a copy of this software and associated documentation ;;; files (the "Software"), to deal in the Software without ;;; restriction, including without limitation the rights to use, copy, ;;; modify, merge, publish, distribute, sublicense, and/or sell copies ;;; of the Software, and to permit persons to whom the Software is ;;; furnished to do so, subject to the following conditions: ;;; ;;; The above copyright notice and this permission notice shall be ;;; included in all copies or substantial portions of the Software. ;;; ;;; THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, ;;; EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF ;;; MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND ;;; NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT ;;; HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, ;;; WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, ;;; OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER ;;; DEALINGS IN THE SOFTWARE. ;;; (in-package #:cffi) (defvar *cif-table* (make-hash-table :test 'equal) "A hash table of foreign functions and pointers to the foreign cif (Call InterFace) structure for that function.") (define-condition foreign-function-not-prepared (error) ((foreign-function-name :initarg :foreign-function-name :reader foreign-function-name)) (:report (lambda (condition stream) (format stream "Foreign function ~a did not prepare correctly" (foreign-function-name condition)))) (:documentation "Preparation of foreign function did not succeed, according to return from libffi library.")) (defun prepare-function (foreign-function-name return-type argument-types &optional (abi :default-abi)) "Generate or retrieve the CIF needed to call the function through libffi." (or (gethash foreign-function-name *cif-table*) (let* ((number-of-arguments (length argument-types)) (cif (cffi:foreign-alloc '(:struct ffi-cif))) (ffi-argtypes (cffi:foreign-alloc :pointer :count number-of-arguments))) (loop for type in argument-types for i from 0 do (setf (cffi:mem-aref ffi-argtypes :pointer i) (libffi-type-pointer (parse-type type)))) (unless (eql :OK (prep-cif cif abi number-of-arguments (libffi-type-pointer (parse-type return-type)) ffi-argtypes)) (error 'foreign-function-not-prepared :foreign-function-name foreign-function-name)) (setf (gethash foreign-function-name *cif-table*) cif) cif))) (defun unprepare-function (foreign-function-name) "Remove prepared definitions for the named foreign function. Returns foreign-function-name if function had been prepared, NIL otherwise." (let ((ptr (gethash foreign-function-name *cif-table*))) (when ptr (cffi:foreign-free (cffi:foreign-slot-value ptr '(:struct ffi-cif) 'argument-types)) (cffi:foreign-free ptr) (remhash foreign-function-name *cif-table*) foreign-function-name))) (defun ffcall-body-libffi (function symbols return-type argument-types &optional pointerp (abi :default-abi)) "A body of foreign-funcall calling the libffi function #'call (ffi_call)." (let ((number-of-arguments (length argument-types))) `(cffi:with-foreign-objects ((argvalues :pointer ,number-of-arguments) ,@(unless (eql return-type :void) `((result ',return-type)))) (loop :for arg :in (list ,@symbols) :for count :from 0 :do (setf (cffi:mem-aref argvalues :pointer count) arg)) (call (prepare-function ,function ',return-type ',argument-types ',abi) ,(if pointerp function `(cffi:foreign-symbol-pointer ,function)) ,(if (eql return-type :void) '(cffi:null-pointer) 'result) argvalues) ,(if (eql return-type :void) '(values) (if (typep (parse-type return-type) 'cffi::translatable-foreign-type) ;; just return the pointer so that expand-from-foreign ;; can apply translate-from-foreign 'result ;; built-in types won't be translated by ;; expand-from-foreign, we have to do it here `(cffi:mem-aref result ',return-type)))))) (setf *foreign-structures-by-value* 'ffcall-body-libffi) (pushnew :fsbv *features*)

Common Lisp

.lisp

cac-t-u-s/om-sharp

GPL-3.0

9/19/2024, 11:25:22 AM (Europe/Amsterdam)

da0c41098c445bf7d2ab687c0d8b1bf7687f269c9b11018be217528f14f3407c

cif.lisp

cac-t-u-s_om-sharp/src/api/foreign-interface/ffi/CFFI/libffi/cif.lisp

;;;; -*- Mode: lisp; indent-tabs-mode: nil -*- ;;; ;;; cif.lisp --- Structure and function call function in libffi ;;; ;;; Copyright (C) 2009, 2010, 2011 Liam Healy <[email protected]> ;;; ;;; Permission is hereby granted, free of charge, to any person ;;; obtaining a copy of this software and associated documentation ;;; files (the "Software"), to deal in the Software without ;;; restriction, including without limitation the rights to use, copy, ;;; modify, merge, publish, distribute, sublicense, and/or sell copies ;;; of the Software, and to permit persons to whom the Software is ;;; furnished to do so, subject to the following conditions: ;;; ;;; The above copyright notice and this permission notice shall be ;;; included in all copies or substantial portions of the Software. ;;; ;;; THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, ;;; EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF ;;; MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND ;;; NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT ;;; HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, ;;; WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, ;;; OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER ;;; DEALINGS IN THE SOFTWARE. ;;; (in-package #:cffi) ;;; Structs (cffi:defcstruct ffi-cif (abi ffi-abi) (number-of-arguments unsigned) (argument-types :pointer) (return-type :pointer) (bytes unsigned) (flags unsigned)) ;;; Functions ;;; See file:///usr/share/doc/libffi-dev/html/The-Basics.html#The-Basics (cffi:defcfun ("ffi_prep_cif" prep-cif) status (ffi-cif :pointer) (ffi-abi abi) (nargs :uint) (rtype :pointer) (argtypes :pointer)) (cffi:defcfun ("ffi_call" call) :void (ffi-cif :pointer) (function :pointer) (rvalue :pointer) (avalues :pointer))

Common Lisp

.lisp

cac-t-u-s/om-sharp

GPL-3.0

9/19/2024, 11:25:22 AM (Europe/Amsterdam)

af6931260e285cf3cce5bc41e5a3bcf00bd94d0c20b45b5bbeab5aab16ce59c2

libffi-win32.lisp

cac-t-u-s_om-sharp/src/api/foreign-interface/ffi/CFFI/libffi/libffi-win32.lisp

;;;; -*- Mode: lisp; indent-tabs-mode: nil -*- ;;; ;;; libffi-win32.lisp -- libffi CFFI-Grovel definitions for Windows. ;;; ;;; Copyright (C) 2009, 2010, 2011, 2012 Liam M. Healy <[email protected]> ;;; ;;; Permission is hereby granted, free of charge, to any person ;;; obtaining a copy of this software and associated documentation ;;; files (the "Software"), to deal in the Software without ;;; restriction, including without limitation the rights to use, copy, ;;; modify, merge, publish, distribute, sublicense, and/or sell copies ;;; of the Software, and to permit persons to whom the Software is ;;; furnished to do so, subject to the following conditions: ;;; ;;; The above copyright notice and this permission notice shall be ;;; included in all copies or substantial portions of the Software. ;;; ;;; THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, ;;; EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF ;;; MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND ;;; NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT ;;; HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, ;;; WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, ;;; OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER ;;; DEALINGS IN THE SOFTWARE. ;;; ;; by CRLF0710, modified from Liam Healy 2009-02-22 09:24:33EST libffi-unix.lisp (in-package #:cffi) (include "ffi.h") (cenum status ((:OK "FFI_OK")) ((:bad-typedef "FFI_BAD_TYPEDEF")) ((:bad-abi "FFI_BAD_ABI"))) (cenum abi ((:default-abi "FFI_DEFAULT_ABI")) ((:sysv "FFI_SYSV")) ((:stdcall "FFI_STDCALL"))) (ctype ffi-abi "ffi_abi") (ctype :sizet "size_t") (ctype ushort "unsigned short") (ctype unsigned "unsigned") (cstruct ffi-type "struct _ffi_type" (size "size" :type :sizet) (alignment "alignment" :type ushort) (type "type" :type ushort) (elements "elements" :type :pointer)) #| ;;; Will not compile ;;; error: invalid application of ‘sizeof’ to incomplete type ‘struct ffi_cif’ ;;; When structs are defined with the name at the end, apparently they ;;; are intended to be "opaque types". (cstruct ffi-cif "struct ffi_cif" (abi "abi" :type ffi-abi) (nargs "nargs" :type unsigned) (arg-types "arg_types" :type :pointer) (return-type "rtype" :type :pointer) (bytes "bytes" :type :unsigned) (flags "flags" :type :unsigned)) |# (constant (+type-void+ "FFI_TYPE_VOID")) (constant (+type-int+ "FFI_TYPE_INT")) (constant (+type-float+ "FFI_TYPE_FLOAT")) (constant (+type-double+ "FFI_TYPE_DOUBLE")) (constant (+type-longdouble+ "FFI_TYPE_LONGDOUBLE")) (constant (+type-uint8+ "FFI_TYPE_UINT8")) (constant (+type-sint8+ "FFI_TYPE_SINT8")) (constant (+type-uint16+ "FFI_TYPE_UINT16")) (constant (+type-sint16+ "FFI_TYPE_SINT16")) (constant (+type-uint32+ "FFI_TYPE_UINT32")) (constant (+type-sint32+ "FFI_TYPE_SINT32")) (constant (+type-uint64+ "FFI_TYPE_UINT64")) (constant (+type-sint64+ "FFI_TYPE_SINT64")) (constant (+type-struct+ "FFI_TYPE_STRUCT")) (constant (+type-pointer+ "FFI_TYPE_POINTER"))

Common Lisp

.lisp

cac-t-u-s/om-sharp

GPL-3.0

9/19/2024, 11:25:22 AM (Europe/Amsterdam)

67674018f5b3efb1732de68fc784400284c5138ca05be510f4577ebaf2371618

init.lisp

cac-t-u-s_om-sharp/src/api/foreign-interface/ffi/CFFI/libffi/init.lisp

;;;; -*- Mode: lisp; indent-tabs-mode: nil -*- ;;; ;;; init.lisp --- Load libffi and define #'libffi-type-pointer ;;; ;;; Copyright (C) 2009, 2011 Liam M. Healy ;;; ;;; Permission is hereby granted, free of charge, to any person ;;; obtaining a copy of this software and associated documentation ;;; files (the "Software"), to deal in the Software without ;;; restriction, including without limitation the rights to use, copy, ;;; modify, merge, publish, distribute, sublicense, and/or sell copies ;;; of the Software, and to permit persons to whom the Software is ;;; furnished to do so, subject to the following conditions: ;;; ;;; The above copyright notice and this permission notice shall be ;;; included in all copies or substantial portions of the Software. ;;; ;;; THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, ;;; EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF ;;; MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND ;;; NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT ;;; HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, ;;; WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, ;;; OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER ;;; DEALINGS IN THE SOFTWARE. ;;; (in-package #:cffi) (cffi:define-foreign-library (libffi) (:darwin (:or "libffi.dylib" "libffi32.dylib")) (:solaris (:or "/usr/lib/amd64/libffi.so" "/usr/lib/libffi.so")) (:unix (:or "libffi.so.6" "libffi32.so.6" "libffi.so.5" "libffi32.so.5")) (:windows (:or "libffi-6.dll" "libffi-5.dll" "libffi.dll")) (t (:default "libffi"))) (cffi:load-foreign-library 'libffi) (defvar *libffi-type-pointer* (make-hash-table)) (defgeneric libffi-type-pointer (object) (:documentation "The type pointer defined by libffi.") (:method ((object symbol)) (libffi-type-pointer (parse-type object))) (:method (object) (gethash object *libffi-type-pointer*))) (defun set-libffi-type-pointer (type pointer) "Set the hash table entry for the libffi type pointer." (setf (gethash (if (symbolp type) (parse-type type) type) *libffi-type-pointer*) pointer))

Common Lisp

.lisp

cac-t-u-s/om-sharp

GPL-3.0

9/19/2024, 11:25:22 AM (Europe/Amsterdam)

daf79d9927ce28821682a9a23f3026d917744b62c18f487611d09aaafcdf04ad

uffi-compat.lisp

cac-t-u-s_om-sharp/src/api/foreign-interface/ffi/CFFI/uffi-compat/uffi-compat.lisp

;;;; -*- Mode: lisp; indent-tabs-mode: nil -*- ;;; ;;; uffi-compat.lisp --- UFFI compatibility layer for CFFI. ;;; ;;; Copyright (C) 2005-2006, James Bielman <[email protected]> ;;; Copyright (C) 2005-2007, Luis Oliveira <[email protected]> ;;; ;;; Permission is hereby granted, free of charge, to any person ;;; obtaining a copy of this software and associated documentation ;;; files (the "Software"), to deal in the Software without ;;; restriction, including without limitation the rights to use, copy, ;;; modify, merge, publish, distribute, sublicense, and/or sell copies ;;; of the Software, and to permit persons to whom the Software is ;;; furnished to do so, subject to the following conditions: ;;; ;;; The above copyright notice and this permission notice shall be ;;; included in all copies or substantial portions of the Software. ;;; ;;; THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, ;;; EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF ;;; MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND ;;; NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT ;;; HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, ;;; WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, ;;; OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER ;;; DEALINGS IN THE SOFTWARE. ;;; ;;; Code borrowed from UFFI is Copyright (c) Kevin M. Rosenberg. (defpackage #:cffi-uffi-compat (:nicknames #:uffi) ;; is this a good idea? (:use #:cl) (:export ;; immediate types #:def-constant #:def-foreign-type #:def-type #:null-char-p ;; aggregate types #:def-enum #:def-struct #:get-slot-value #:get-slot-pointer #:def-array-pointer #:deref-array #:def-union ;; objects #:allocate-foreign-object #:free-foreign-object #:with-foreign-object #:with-foreign-objects #:size-of-foreign-type #:pointer-address #:deref-pointer #:ensure-char-character #:ensure-char-integer #:ensure-char-storable #:null-pointer-p #:make-null-pointer #:make-pointer #:+null-cstring-pointer+ #:char-array-to-pointer #:with-cast-pointer #:def-foreign-var #:convert-from-foreign-usb8 #:def-pointer-var ;; string functions #:convert-from-cstring #:convert-to-cstring #:free-cstring #:with-cstring #:with-cstrings #:convert-from-foreign-string #:convert-to-foreign-string #:allocate-foreign-string #:with-foreign-string #:with-foreign-strings #:foreign-string-length ; not implemented #:string-to-octets #:octets-to-string #:foreign-encoded-octet-count ;; function call #:def-function ;; libraries #:find-foreign-library #:load-foreign-library #:default-foreign-library-type #:foreign-library-types ;; os #:getenv #:run-shell-command )) (in-package #:cffi-uffi-compat) #+clisp (eval-when (:compile-toplevel :load-toplevel :execute) (when (equal (machine-type) "POWER MACINTOSH") (pushnew :ppc *features*))) (defun convert-uffi-type (uffi-type) "Convert a UFFI primitive type to a CFFI type." ;; Many CFFI types are the same as UFFI. This list handles the ;; exceptions only. (case uffi-type (:cstring :pointer) (:pointer-void :pointer) (:pointer-self :pointer) ;; Although UFFI's documentation claims dereferencing :CHAR and ;; :UNSIGNED-CHAR returns characters, it actually returns ;; integers. (:char :char) (:unsigned-char :unsigned-char) (:byte :char) (:unsigned-byte :unsigned-char) (t (if (listp uffi-type) (case (car uffi-type) ;; this is imho gross but it is what uffi does (quote (convert-uffi-type (second uffi-type))) (* :pointer) (:array `(uffi-array ,(convert-uffi-type (second uffi-type)) ,(third uffi-type))) (:union (second uffi-type)) (:struct (convert-uffi-type (second uffi-type))) (:struct-pointer :pointer)) uffi-type)))) (cffi:define-foreign-type uffi-array-type () ;; ELEMENT-TYPE should be /unparsed/, suitable for passing to mem-aref. ((element-type :initform (error "An element-type is required.") :accessor element-type :initarg :element-type) (nelems :initform (error "nelems is required.") :accessor nelems :initarg :nelems)) (:actual-type :pointer) (:documentation "UFFI's :array type.")) (cffi:define-parse-method uffi-array (element-type count) (make-instance 'uffi-array-type :element-type element-type :nelems (or count 1))) (defmethod cffi:foreign-type-size ((type uffi-array-type)) (* (cffi:foreign-type-size (element-type type)) (nelems type))) (defmethod cffi::aggregatep ((type uffi-array-type)) t) ;; UFFI's :(unsigned-)char #+#:ignore (cffi:define-foreign-type uffi-char () ()) #+#:ignore (cffi:define-parse-method uffi-char (base-type) (make-instance 'uffi-char :actual-type base-type)) #+#:ignore (defmethod cffi:translate-to-foreign ((value character) (type uffi-char)) (char-code value)) #+#:ignore (defmethod cffi:translate-from-foreign (obj (type uffi-char)) (code-char obj)) (defmacro def-type (name type) "Define a Common Lisp type NAME for UFFI type TYPE." (declare (ignore type)) `(deftype ,name () t)) (defmacro def-foreign-type (name type) "Define a new foreign type." `(cffi:defctype ,name ,(convert-uffi-type type))) (defmacro def-constant (name value &key export) "Define a constant and conditionally export it." `(eval-when (:compile-toplevel :load-toplevel :execute) (defconstant ,name ,value) ,@(when export `((export ',name))) ',name)) (defmacro null-char-p (val) "Return true if character is null." `(zerop (char-code ,val))) (defmacro def-enum (enum-name args &key (separator-string "#")) "Creates a constants for a C type enum list, symbols are created in the created in the current package. The symbol is the concatenation of the enum-name name, separator-string, and field-name" (let ((counter 0) (cmds nil) (constants nil)) (declare (fixnum counter)) (dolist (arg args) (let ((name (if (listp arg) (car arg) arg)) (value (if (listp arg) (prog1 (setq counter (cadr arg)) (incf counter)) (prog1 counter (incf counter))))) (setq name (intern (concatenate 'string (symbol-name enum-name) separator-string (symbol-name name)))) (push `(def-constant ,name ,value) constants))) (setf cmds (append '(progn) `((cffi:defctype ,enum-name :int)) (nreverse constants))) cmds)) (defmacro def-struct (name &body fields) "Define a C structure." `(cffi:defcstruct ,name ,@(loop for (name uffi-type) in fields for cffi-type = (convert-uffi-type uffi-type) collect (list name cffi-type)))) ;; TODO: figure out why the compiler macro is kicking in before ;; the setf expander. (defun %foreign-slot-value (obj type field) (cffi:foreign-slot-value obj type field)) (defun (setf %foreign-slot-value) (value obj type field) (setf (cffi:foreign-slot-value obj type field) value)) (defmacro get-slot-value (obj type field) "Access a slot value from a structure." `(%foreign-slot-value ,obj ,type ,field)) ;; UFFI uses a different function when accessing a slot whose ;; type is a pointer. We don't need that in CFFI so we use ;; foreign-slot-value too. (defmacro get-slot-pointer (obj type field) "Access a pointer slot value from a structure." `(cffi:foreign-slot-value ,obj ,type ,field)) (defmacro def-array-pointer (name type) "Define a foreign array type." `(cffi:defctype ,name (uffi-array ,(convert-uffi-type type) 1))) (defmacro deref-array (array type position) "Dereference an array." `(cffi:mem-aref ,array ,(if (constantp type) `',(element-type (cffi::parse-type (convert-uffi-type (eval type)))) `(element-type (cffi::parse-type (convert-uffi-type ,type)))) ,position)) ;; UFFI's documentation on DEF-UNION is a bit scarce, I'm not sure ;; if DEFCUNION and DEF-UNION are strictly compatible. (defmacro def-union (name &body fields) "Define a foreign union type." `(cffi:defcunion ,name ,@(loop for (name uffi-type) in fields for cffi-type = (convert-uffi-type uffi-type) collect (list name cffi-type)))) (defmacro allocate-foreign-object (type &optional (size 1)) "Allocate one or more instance of a foreign type." `(cffi:foreign-alloc ,(if (constantp type) `',(convert-uffi-type (eval type)) `(convert-uffi-type ,type)) :count ,size)) (defmacro free-foreign-object (ptr) "Free a foreign object allocated by ALLOCATE-FOREIGN-OBJECT." `(cffi:foreign-free ,ptr)) (defmacro with-foreign-object ((var type) &body body) "Wrap the allocation of a foreign object around BODY." `(cffi:with-foreign-object (,var (convert-uffi-type ,type)) ,@body)) ;; Taken from UFFI's src/objects.lisp (defmacro with-foreign-objects (bindings &rest body) (if bindings `(with-foreign-object ,(car bindings) (with-foreign-objects ,(cdr bindings) ,@body)) `(progn ,@body))) (defmacro size-of-foreign-type (type) "Return the size in bytes of a foreign type." `(cffi:foreign-type-size (convert-uffi-type ,type))) (defmacro pointer-address (ptr) "Return the address of a pointer." `(cffi:pointer-address ,ptr)) (defmacro deref-pointer (ptr type) "Dereference a pointer." `(cffi:mem-ref ,ptr (convert-uffi-type ,type))) (defsetf deref-pointer (ptr type) (value) `(setf (cffi:mem-ref ,ptr (convert-uffi-type ,type)) ,value)) (defmacro ensure-char-character (obj &environment env) "Convert OBJ to a character if it is an integer." (if (constantp obj env) (if (characterp obj) obj (code-char obj)) (let ((obj-var (gensym))) `(let ((,obj-var ,obj)) (if (characterp ,obj-var) ,obj-var (code-char ,obj-var)))))) (defmacro ensure-char-integer (obj &environment env) "Convert OBJ to an integer if it is a character." (if (constantp obj env) (let ((the-obj (eval obj))) (if (characterp the-obj) (char-code the-obj) the-obj)) (let ((obj-var (gensym))) `(let ((,obj-var ,obj)) (if (characterp ,obj-var) (char-code ,obj-var) ,obj-var))))) (defmacro ensure-char-storable (obj) "Ensure OBJ is storable as a character." `(ensure-char-integer ,obj)) (defmacro make-null-pointer (type) "Create a NULL pointer." (declare (ignore type)) `(cffi:null-pointer)) (defmacro make-pointer (address type) "Create a pointer to ADDRESS." (declare (ignore type)) `(cffi:make-pointer ,address)) (defmacro null-pointer-p (ptr) "Return true if PTR is a null pointer." `(cffi:null-pointer-p ,ptr)) (defparameter +null-cstring-pointer+ (cffi:null-pointer) "A constant NULL string pointer.") (defmacro char-array-to-pointer (obj) obj) (defmacro with-cast-pointer ((var ptr type) &body body) "Cast a pointer, does nothing in CFFI." (declare (ignore type)) `(let ((,var ,ptr)) ,@body)) (defmacro def-foreign-var (name type module) "Define a symbol macro to access a foreign variable." (declare (ignore module)) (flet ((lisp-name (name) (intern (cffi-sys:canonicalize-symbol-name-case (substitute #\- #\_ name))))) `(cffi:defcvar ,(if (listp name) name (list name (lisp-name name))) ,(convert-uffi-type type)))) (defmacro def-pointer-var (name value &optional doc) #-openmcl `(defvar ,name ,value ,@(if doc (list doc))) #+openmcl `(ccl::defloadvar ,name ,value ,doc)) (defmacro convert-from-cstring (s) "Convert a cstring to a Lisp string." (let ((ret (gensym))) `(let ((,ret (cffi:foreign-string-to-lisp ,s))) (if (equal ,ret "") nil ,ret)))) (defmacro convert-to-cstring (obj) "Convert a Lisp string to a cstring." (let ((str (gensym))) `(let ((,str ,obj)) (if (null ,str) (cffi:null-pointer) (cffi:foreign-string-alloc ,str))))) (defmacro free-cstring (ptr) "Free a cstring." `(cffi:foreign-string-free ,ptr)) (defmacro with-cstring ((foreign-string lisp-string) &body body) "Binds a newly creating string." (let ((str (gensym)) (body-proc (gensym))) `(flet ((,body-proc (,foreign-string) ,@body)) (let ((,str ,lisp-string)) (if (null ,str) (,body-proc (cffi:null-pointer)) (cffi:with-foreign-string (,foreign-string ,str) (,body-proc ,foreign-string))))))) ;; Taken from UFFI's src/strings.lisp (defmacro with-cstrings (bindings &rest body) (if bindings `(with-cstring ,(car bindings) (with-cstrings ,(cdr bindings) ,@body)) `(progn ,@body))) (defmacro def-function (name args &key module (returning :void)) "Define a foreign function." (declare (ignore module)) `(cffi:defcfun ,name ,(convert-uffi-type returning) ,@(loop for (name type) in args collect `(,name ,(convert-uffi-type type))))) ;;; Taken from UFFI's src/libraries.lisp (defvar *loaded-libraries* nil "List of foreign libraries loaded. Used to prevent reloading a library") (defun default-foreign-library-type () "Returns string naming default library type for platform" #+(or win32 cygwin mswindows) "dll" #+(or macos macosx darwin ccl-5.0) "dylib" #-(or win32 cygwin mswindows macos macosx darwin ccl-5.0) "so") (defun foreign-library-types () "Returns list of string naming possible library types for platform, sorted by preference" #+(or win32 cygwin mswindows) '("dll" "lib" "so") #+(or macos macosx darwin ccl-5.0) '("dylib" "bundle") #-(or win32 cygwin mswindows macos macosx darwin ccl-5.0) '("so" "a" "o")) (defun find-foreign-library (names directories &key types drive-letters) "Looks for a foreign library. directories can be a single string or a list of strings of candidate directories. Use default library type if type is not specified." (unless types (setq types (foreign-library-types))) (unless (listp types) (setq types (list types))) (unless (listp names) (setq names (list names))) (unless (listp directories) (setq directories (list directories))) #+(or win32 mswindows) (unless (listp drive-letters) (setq drive-letters (list drive-letters))) #-(or win32 mswindows) (setq drive-letters '(nil)) (dolist (drive-letter drive-letters) (dolist (name names) (dolist (dir directories) (dolist (type types) (let ((path (make-pathname #+lispworks :host #+lispworks (when drive-letter drive-letter) #-lispworks :device #-lispworks (when drive-letter drive-letter) :name name :type type :directory (etypecase dir (pathname (pathname-directory dir)) (list dir) (string (pathname-directory (parse-namestring dir))))))) (when (probe-file path) (return-from find-foreign-library path))))))) nil) (defun convert-supporting-libraries-to-string (libs) (let (lib-load-list) (dolist (lib libs) (push (format nil "-l~A" lib) lib-load-list)) (nreverse lib-load-list))) (defun load-foreign-library (filename &key module supporting-libraries force-load) #+(or allegro mcl sbcl clisp) (declare (ignore module supporting-libraries)) #+(or cmu scl sbcl) (declare (ignore module)) (when (and filename (or (null (pathname-directory filename)) (probe-file filename))) (if (pathnamep filename) ;; ensure filename is a string to check if (setq filename (namestring filename))) ; already loaded (if (and (not force-load) (find filename *loaded-libraries* :test #'string-equal)) t ;; return T, but don't reload library (progn ;; FIXME: Hmm, what are these two for? #+cmu (let ((type (pathname-type (parse-namestring filename)))) (if (string-equal type "so") (sys::load-object-file filename) (alien:load-foreign filename :libraries (convert-supporting-libraries-to-string supporting-libraries)))) #+scl (let ((type (pathname-type (parse-namestring filename)))) (if (string-equal type "so") (sys::load-dynamic-object filename) (alien:load-foreign filename :libraries (convert-supporting-libraries-to-string supporting-libraries)))) #-(or cmu scl) (cffi:load-foreign-library filename) (push filename *loaded-libraries*) t)))) ;; Taken from UFFI's src/os.lisp (defun getenv (var) "Return the value of the environment variable." #+allegro (sys::getenv (string var)) #+clisp (sys::getenv (string var)) #+(or cmu scl) (cdr (assoc (string var) ext:*environment-list* :test #'equalp :key #'string)) #+gcl (si:getenv (string var)) #+lispworks (lw:environment-variable (string var)) #+lucid (lcl:environment-variable (string var)) #+(or mcl ccl) (ccl::getenv var) #+sbcl (sb-ext:posix-getenv var) #-(or allegro clisp cmu scl gcl lispworks lucid mcl ccl sbcl) (error 'not-implemented :proc (list 'getenv var))) ;; Taken from UFFI's src/os.lisp ;; modified from function ASDF -- Copyright Dan Barlow and Contributors (defun run-shell-command (control-string &rest args &key output) "Interpolate ARGS into CONTROL-STRING as if by FORMAT, and synchronously execute the result using a Bourne-compatible shell, with output to *trace-output*. Returns the shell's exit code." (unless output (setq output *trace-output*)) (let ((command (apply #'format nil control-string args))) #+sbcl (sb-impl::process-exit-code (sb-ext:run-program "/bin/sh" (list "-c" command) :input nil :output output)) #+(or cmu scl) (ext:process-exit-code (ext:run-program "/bin/sh" (list "-c" command) :input nil :output output)) #+allegro (excl:run-shell-command command :input nil :output output) #+lispworks (system:call-system-showing-output command :shell-type "/bin/sh" :output-stream output) #+clisp ;XXX not exactly *trace-output*, I know (ext:run-shell-command command :output :terminal :wait t) #+openmcl (nth-value 1 (ccl:external-process-status (ccl:run-program "/bin/sh" (list "-c" command) :input nil :output output :wait t))) #-(or openmcl clisp lispworks allegro scl cmu sbcl) (error "RUN-SHELL-PROGRAM not implemented for this Lisp") )) ;;; Some undocumented UFFI operators... (defmacro convert-from-foreign-string (obj &key length (locale :default) (encoding 'cffi:*default-foreign-encoding*) (null-terminated-p t)) ;; in effect, (eq NULL-TERMINATED-P (null LENGTH)). Hopefully, ;; that's compatible with the intended semantics, which are ;; undocumented. If that's not the case, we can implement ;; NULL-TERMINATED-P in CFFI:FOREIGN-STRING-TO-LISP. (declare (ignore locale null-terminated-p)) (let ((ret (gensym))) `(let ((,ret (cffi:foreign-string-to-lisp ,obj :count ,length :encoding ,encoding))) (if (equal ,ret "") nil ,ret)))) ;; What's the difference between this and convert-to-cstring? (defmacro convert-to-foreign-string (obj &optional (encoding 'cffi:*default-foreign-encoding*)) (let ((str (gensym))) `(let ((,str ,obj)) (if (null ,str) (cffi:null-pointer) (cffi:foreign-string-alloc ,str :encoding ,encoding))))) (defmacro allocate-foreign-string (size &key unsigned) (declare (ignore unsigned)) `(cffi:foreign-alloc :char :count ,size)) ;; Ditto. (defmacro with-foreign-string ((foreign-string lisp-string) &body body) (let ((str (gensym))) `(let ((,str ,lisp-string)) (if (null ,str) (let ((,foreign-string (cffi:null-pointer))) ,@body) (cffi:with-foreign-string (,foreign-string ,str) ,@body))))) (defmacro with-foreign-strings (bindings &body body) `(with-foreign-string ,(car bindings) ,@(if (cdr bindings) `((with-foreign-strings ,(cdr bindings) ,@body)) body))) ;; This function returns a form? Where is this used in user-code? (defun foreign-string-length (foreign-string) (declare (ignore foreign-string)) (error "FOREIGN-STRING-LENGTH not implemented.")) ;; This should be optimized. (defun convert-from-foreign-usb8 (s len) (let ((a (make-array len :element-type '(unsigned-byte 8)))) (dotimes (i len a) (setf (aref a i) (cffi:mem-ref s :unsigned-char i))))) ;;;; String Encodings (defmacro string-to-octets (str &key encoding null-terminate) `(babel:concatenate-strings-to-octets (or ,encoding cffi:*default-foreign-encoding*) ,str (if ,null-terminate #.(string #\Nul) ""))) (defmacro octets-to-string (octets &key encoding) `(babel:octets-to-string ,octets :encoding (or ,encoding cffi:*default-foreign-encoding*))) (defun foreign-encoded-octet-count (str &key encoding) (babel:string-size-in-octets str :encoding (or encoding cffi:*default-foreign-encoding*)))

Common Lisp

.lisp

cac-t-u-s/om-sharp

GPL-3.0

9/19/2024, 11:25:22 AM (Europe/Amsterdam)

aa4f64b1783f2485eb4d9cb56ca5009ea283f6ec694b5f8c3eadbeb1c782716c

release.lisp

cac-t-u-s_om-sharp/src/api/foreign-interface/ffi/CFFI/scripts/release.lisp

#!/usr/bin/env clisp ;;;; -*- Mode: lisp; indent-tabs-mode: nil -*- (defpackage :release-script (:use #:cl #:regexp)) (in-package :release-script) ;;;; Configuration ------------------------------------------------------------ (defparameter *project-name* "cffi") (defparameter *asdf-file* (format nil "~A.asd" *project-name*)) (defparameter *host* "common-lisp.net") (defparameter *release-dir* (format nil "/project/~A/public_html/releases" *project-name*)) (defparameter *version-file* "VERSION") (defparameter *version-file-dir* (format nil "/project/~A/public_html" *project-name*)) ;;;; -------------------------------------------------------------------------- ;;;; Utilities (defun ensure-list (x) (if (listp x) x (list x))) (defmacro string-case (expression &body clauses) `(let ((it ,expression)) ; yes, anaphoric, deal with it. (cond ,@(loop for clause in clauses collect `((or ,@(loop for alternative in (ensure-list (first clause)) collect (or (eq t alternative) `(string= it ,alternative)))) ,@(rest clause)))))) (defparameter *development-mode* nil) (defun die (format-control &rest format-args) (format *error-output* "~?" format-control format-args) (if *development-mode* (cerror "continue" "die") (ext:quit 1))) (defun numeric-split (string) (if (digit-char-p (char string 0)) (multiple-value-bind (number next-position) (parse-integer string :junk-allowed t) (cons number (when (< next-position (length string)) (numeric-split (subseq string next-position))))) (let ((next-digit-position (position-if #'digit-char-p string))) (if next-digit-position (cons (subseq string 0 next-digit-position) (numeric-split (subseq string next-digit-position))) (list string))))) (defun natural-string-< (s1 s2) (labels ((aux< (l1 l2) (cond ((null l1) (not (null l2))) ((null l2) nil) (t (destructuring-bind (x . xs) l1 (destructuring-bind (y . ys) l2 (cond ((and (numberp x) (stringp y)) t) ((and (numberp y) (stringp x)) nil) ((and (numberp x) (numberp y)) (or (< x y) (and (= x y) (aux< xs ys)))) (t (or (string-lessp x y) (and (string-equal x y) (aux< xs ys))))))))))) (aux< (numeric-split s1) (numeric-split s2)))) ;;;; Running commands (defparameter *dry-run* nil) (defun cmd? (format-control &rest format-args) (let ((cmd (format nil "~?" format-control format-args))) (with-open-stream (s1 (ext:run-shell-command cmd :output :stream)) (loop for line = (read-line s1 nil nil) while line collect line)))) ;; XXX: quote arguments. (defun cmd (format-control &rest format-args) (when *development-mode* (format *debug-io* "CMD: ~?~%" format-control format-args)) (let ((ret (ext:run-shell-command (format nil "~?" format-control format-args)))) (or (null ret) (zerop ret)))) (defun cmd! (format-control &rest format-args) (or (apply #'cmd format-control format-args) (die "cmd '~?' failed." format-control format-args))) (defun maybe-cmd! (format-control &rest format-args) (if *dry-run* (format t "SUPPRESSING: ~?~%" format-control format-args) (apply #'cmd! format-control format-args))) ;;;; (defun find-current-version () (subseq (reduce (lambda (x y) (if (natural-string-< x y) y x)) (or (cmd? "git tag -l v\\*") (die "no version tags found. Please specify initial version."))) 1)) (defun parse-version (string) (mapcar (lambda (x) (parse-integer x :junk-allowed t)) (loop repeat 3 ; XXX: parameterize for el in (regexp-split "\\." (find-current-version)) collect el))) (defun check-for-unrecorded-changes (&optional force) (unless (cmd "git diff --exit-code") (write-line "Unrecorded changes.") (if force (write-line "Continuing anyway.") (die "Aborting.~@ Use -f or --force if you want to make a release anyway.")))) (defun new-version-number-candidates (current-version) (let ((current-version (parse-version current-version))) (labels ((alternatives (before after) (when after (cons (append before (list (1+ (first after))) (mapcar (constantly 0) (rest after))) (alternatives (append before (list (first after))) (rest after)))))) (loop for alt in (alternatives nil current-version) collect (reduce (lambda (acc next) (format nil "~a.~a" acc next)) alt))))) (defun ask-user-for-version (current-version next-versions) (format *query-io* "Current version is ~A. Which will be the next one?~%" current-version) (loop for i from 1 and version in next-versions do (format *query-io* "~T~A) ~A~%" i version)) (format *query-io* "? ") (finish-output *query-io*) (nth (1- (parse-integer (read-line) :junk-allowed t)) next-versions)) (defun git-tag-tree (version) (write-line "Tagging the tree...") (maybe-cmd! "git tag \"v~A\"" version)) (defun add-version-to-system-file (version path-in path-out) (let ((defsystem-line (format nil "(defsystem :~A" *project-name*))) (with-open-file (in path-in :direction :input) (with-open-file (out path-out :direction :output) (loop for line = (read-line in nil nil) while line do (write-line line out) when (string= defsystem-line line) do (format out " :version ~s~%" version)))))) (defun create-dist (version distname) (write-line "Creating distribution...") (cmd! "mkdir \"~a\"" distname) (cmd! "git archive master | tar xC \"~A\"" distname) (format t "Updating ~A with new version: ~A~%" *asdf-file* version) (let* ((asdf-file-path (format nil "~A/~A" distname *asdf-file*)) (tmp-asdf-file-path (format nil "~a.tmp" asdf-file-path))) (add-version-to-system-file version asdf-file-path tmp-asdf-file-path) (cmd! "mv \"~a\" \"~a\"" tmp-asdf-file-path asdf-file-path))) (defun tar-and-sign (distname tarball) (write-line "Creating and signing tarball...") (cmd! "tar czf \"~a\" \"~a\"" tarball distname) (cmd! "gpg -b -a \"~a\"" tarball)) (defparameter *remote-directory* (format nil "~A:~A" *host* *release-dir*)) (defun upload-tarball (tarball signature remote-directory) (write-line "Copying tarball to web server...") (maybe-cmd! "scp \"~A\" \"~A\" \"~A\"" tarball signature remote-directory) (format t "Uploaded ~A and ~A.~%" tarball signature)) (defun update-remote-links (tarball signature host release-dir project-name) (format t "Updating ~A_latest links...~%" project-name) (maybe-cmd! "ssh \"~A\" ln -sf \"~A\" \"~A/~A_latest.tar.gz\"" host tarball release-dir project-name) (maybe-cmd! "ssh \"~A\" ln -sf \"~A\" \"~A/~A_latest.tar.gz.asc\"" host signature release-dir project-name)) (defun upload-version-file (version version-file host version-file-dir) (format t "Uploading ~A...~%" version-file) (with-open-file (out version-file :direction :output) (write-string version out)) (maybe-cmd! "scp \"~A\" \"~A\":\"~A\"" version-file host version-file-dir) (maybe-cmd! "rm \"~A\"" version-file)) (defun maybe-clean-things-up (tarball signature) (when (y-or-n-p "Clean local tarball and signature?") (cmd! "rm \"~A\" \"~A\"" tarball signature))) (defun run (force version) (check-for-unrecorded-changes force) ;; figure out what version we'll be preparing. (unless version (let* ((current-version (find-current-version)) (next-versions (new-version-number-candidates current-version))) (setf version (or (ask-user-for-version current-version next-versions) (die "invalid selection."))))) (git-tag-tree version) (let* ((distname (format nil "~A_~A" *project-name* version)) (tarball (format nil "~A.tar.gz" distname)) (signature (format nil "~A.asc" tarball))) ;; package things up. (create-dist version distname) (tar-and-sign distname tarball) ;; upload. (upload-tarball tarball signature *remote-directory*) (update-remote-links tarball signature *host* *release-dir* *project-name*) (when *version-file* (upload-version-file version *version-file* *host* *version-file-dir*)) ;; clean up. (maybe-clean-things-up tarball signature) ;; documentation. (write-line "Building and uploading documentation...") (maybe-cmd! "make -C doc upload-docs") ;; push tags and any outstanding changes. (write-line "Pushing tags and changes...") (maybe-cmd! "git push --tags origin master"))) ;;;; Do it to it (let ((force nil) (version nil) (args ext:*args*)) (loop while args do (string-case (pop args) (("-h" "--help") (write-line "No help, sorry. Read the source.") (ext:quit 0)) (("-f" "--force") (setf force t)) (("-v" "--version") (setf version (pop args))) (("-n" "--dry-run") (setf *dry-run* t)) (t (die "Unrecognized argument '~a'" it)))) (run force version))

Common Lisp

.lisp

cac-t-u-s/om-sharp

GPL-3.0

9/19/2024, 11:25:22 AM (Europe/Amsterdam)

1e9fbde77c86370c00ebbe5b166b4aedbea4d564792b0898443147130c0947b3

enc-jpn.lisp

cac-t-u-s_om-sharp/src/api/foreign-interface/ffi/babel/src/enc-jpn.lisp

;;;; -*- Mode: lisp; indent-tabs-mode: nil -*- ;;; ;;; enc-jpn.lisp --- Japanese encodings. ;;; (in-package #:babel-encodings) ;;;; helper functions (defvar *eucjp-to-ucs-hash* (make-hash-table)) (defvar *ucs-to-eucjp-hash* (make-hash-table)) (defvar *cp932-to-ucs-hash* (make-hash-table)) (defvar *ucs-to-cp932-hash* (make-hash-table)) (dolist (i `((,*cp932-only* ,*cp932-to-ucs-hash* ,*ucs-to-cp932-hash*) (,*eucjp-only* ,*eucjp-to-ucs-hash* ,*ucs-to-eucjp-hash*) (,*eucjp* ,*eucjp-to-ucs-hash* ,*ucs-to-eucjp-hash*))) (dolist (j (first i)) (setf (gethash (car j) (second i)) (cadr j)) (setf (gethash (cadr j) (third i)) (car j)))) (flet ((euc-cp932 (x) (let ((high (ash x -16)) (mid (logand (ash x -8) 255)) (low (logand x 255))) (cond ((not (zerop high)) nil) ((= mid #x8e) (logand x 255)) ((zerop mid) x) ((decf mid #xa1) (decf low #x80) (incf low (if (zerop (logand mid 1)) #x1f #x7e)) (incf low (if (<= #x7f low #x9d) 1 0)) (setq mid (ash mid -1)) (incf mid (if (<= mid #x1e) #x81 #xc1)) (+ (ash mid 8) low)))))) (dolist (i *eucjp*) (let ((cp932 (euc-cp932 (first i)))) (setf (gethash cp932 *cp932-to-ucs-hash*) (second i)) (setf (gethash (second i) *ucs-to-cp932-hash*) cp932)))) ;ascii (loop for i from #x00 to #x7f do (setf (gethash i *cp932-to-ucs-hash*) i) (setf (gethash i *eucjp-to-ucs-hash*) i) (setf (gethash i *ucs-to-eucjp-hash*) i) (setf (gethash i *ucs-to-cp932-hash*) i)) ;half-width katakana (loop for i from #xa1 to #xdf do (setf (gethash i *cp932-to-ucs-hash*) (+ #xff61 #x-a1 i)) (setf (gethash (+ #xff61 #x-a1 i) *ucs-to-cp932-hash*) i) (setf (gethash (+ #x8e00 i) *eucjp-to-ucs-hash*) (+ #xff61 #x-a1 i)) (setf (gethash (+ #xff61 #x-a1 i) *ucs-to-eucjp-hash*) (+ #x8e00 i))) (defun eucjp-to-ucs (code) (values (gethash code *eucjp-to-ucs-hash*))) (defun ucs-to-eucjp (code) (values (gethash code *ucs-to-eucjp-hash*))) (defun cp932-to-ucs (code) (values (gethash code *cp932-to-ucs-hash*))) (defun ucs-to-cp932 (code) (values (gethash code *ucs-to-cp932-hash*))) ;;;; EUC-JP (define-character-encoding :eucjp "An 8-bit, variable-length character encoding in which character code points in the range #x00-#x7f can be encoded in a single octet; characters with larger code values can be encoded in 2 to 3 bytes." :max-units-per-char 3 :literal-char-code-limit #x80) (define-octet-counter :eucjp (getter type) `(named-lambda eucjp-octet-counter (seq start end max) (declare (type ,type seq) (fixnum start end max)) (loop with noctets fixnum = 0 for i fixnum from start below end for code of-type code-point = (,getter seq i) do (let* ((c (ucs-to-eucjp code)) (new (+ (cond ((< #xffff c) 3) ((< #xff c) 2) (t 1)) noctets))) (if (and (plusp max) (> new max)) (loop-finish) (setq noctets new))) finally (return (values noctets i))))) (define-code-point-counter :eucjp (getter type) `(named-lambda eucjp-code-point-counter (seq start end max) (declare (type ,type seq) (fixnum start end max)) (loop with nchars fixnum = 0 with i fixnum = start while (< i end) do (let* ((octet (,getter seq i)) (next-i (+ i (cond ((= #x8f octet) 3) ((or (< #xa0 octet #xff) (= #x8e octet)) 2) (t 1))))) (declare (type ub8 octet) (fixnum next-i)) (cond ((> next-i end) ;; Should we add restarts to this error, we'll have ;; to figure out a way to communicate with the ;; decoder since we probably want to do something ;; about it right here when we have a chance to ;; change the count or something. (Like an ;; alternative replacement character or perhaps the ;; existence of this error so that the decoder ;; doesn't have to check for it on every iteration ;; like we do.) ;; ;; FIXME: The data for this error is not right. (decoding-error (vector octet) :eucjp seq i nil 'end-of-input-in-character) (return (values (1+ nchars) end))) (t (setq nchars (1+ nchars) i next-i) (when (and (plusp max) (= nchars max)) (return (values nchars i)))))) finally (progn (assert (= i end)) (return (values nchars i)))))) (define-encoder :eucjp (getter src-type setter dest-type) `(named-lambda eucjp-encoder (src start end dest d-start) (declare (type ,src-type src) (type ,dest-type dest) (fixnum start end d-start)) (loop with di fixnum = d-start for i fixnum from start below end for code of-type code-point = (,getter src i) for eucjp of-type code-point = (ucs-to-eucjp code) do (macrolet ((set-octet (offset value) `(,',setter ,value dest (the fixnum (+ di ,offset))))) (cond ;; 1 octet ((< eucjp #x100) (set-octet 0 eucjp) (incf di)) ;; 2 octets ((< eucjp #x10000) (set-octet 0 (f-logand #xff (f-ash eucjp -8))) (set-octet 1 (logand eucjp #xff)) (incf di 2)) ;; 3 octets (t (set-octet 0 (f-logand #xff (f-ash eucjp -16))) (set-octet 1 (f-logand #xff (f-ash eucjp -8))) (set-octet 2 (logand eucjp #xff)) (incf di 3)) )) finally (return (the fixnum (- di d-start)))))) (define-decoder :eucjp (getter src-type setter dest-type) `(named-lambda eucjp-decoder (src start end dest d-start) (declare (type ,src-type src) (type ,dest-type dest) (fixnum start end d-start)) (let ((u2 0)) (declare (type ub8 u2)) (loop for di fixnum from d-start for i fixnum from start below end for u1 of-type ub8 = (,getter src i) do ;; Note: CONSUME-OCTET doesn't check if I is being ;; incremented past END. We're assuming that END has ;; been calculated with the CODE-POINT-POINTER above that ;; checks this. (macrolet ((consume-octet () `(let ((next-i (incf i))) (if (= next-i end) ;; FIXME: data for this error is incomplete. ;; and signalling this error twice (return-from setter-block (decoding-error nil :eucjp src i +repl+ 'end-of-input-in-character)) (,',getter src next-i)))) (handle-error (n &optional (c 'character-decoding-error)) `(decoding-error (vector ,@(subseq '(u1 u2) 0 n)) :eucjp src (1+ (- i ,n)) +repl+ ',c)) (handle-error-if-icb (var n) `(when (not (< #x7f ,var #xc0)) (decf i) (return-from setter-block (handle-error ,n invalid-utf8-continuation-byte))))) (,setter (block setter-block (cond ;; 3 octets ((= u1 #x8f) (setq u2 (consume-octet)) (eucjp-to-ucs (logior #x8f0000 (f-ash u2 8) (consume-octet)))) ;; 2 octets ((or (= u1 #x8e) (< #xa0 u1 #xff)) (eucjp-to-ucs (logior (f-ash u1 8) (consume-octet)))) ;; 1 octet (t (eucjp-to-ucs u1)))) dest di)) finally (return (the fixnum (- di d-start))))))) ;;;; CP932 (define-character-encoding :cp932 "An 8-bit, variable-length character encoding in which character code points in the range #x00-#x7f can be encoded in a single octet; characters with larger code values can be encoded in 2 bytes." :max-units-per-char 2 :literal-char-code-limit #x80) (define-octet-counter :cp932 (getter type) `(named-lambda cp932-octet-counter (seq start end max) (declare (type ,type seq) (fixnum start end max)) (loop with noctets fixnum = 0 for i fixnum from start below end for code of-type code-point = (,getter seq i) do (let* ((c (ucs-to-cp932 code)) (new (+ (cond ((< #xff c) 2) (t 1)) noctets))) (if (and (plusp max) (> new max)) (loop-finish) (setq noctets new))) finally (return (values noctets i))))) (define-code-point-counter :cp932 (getter type) `(named-lambda cp932-code-point-counter (seq start end max) (declare (type ,type seq) (fixnum start end max)) (loop with nchars fixnum = 0 with i fixnum = start while (< i end) do (let* ((octet (,getter seq i)) (next-i (+ i (cond ((or (<= #x81 octet #x9f) (<= #xe0 octet #xfc)) 2) (t 1))))) (declare (type ub8 octet) (fixnum next-i)) (cond ((> next-i end) ;; Should we add restarts to this error, we'll have ;; to figure out a way to communicate with the ;; decoder since we probably want to do something ;; about it right here when we have a chance to ;; change the count or something. (Like an ;; alternative replacement character or perhaps the ;; existence of this error so that the decoder ;; doesn't have to check for it on every iteration ;; like we do.) ;; ;; FIXME: The data for this error is not right. (decoding-error (vector octet) :cp932 seq i nil 'end-of-input-in-character) (return (values (1+ nchars) end))) (t (setq nchars (1+ nchars) i next-i) (when (and (plusp max) (= nchars max)) (return (values nchars i)))))) finally (progn (assert (= i end)) (return (values nchars i)))))) (define-encoder :cp932 (getter src-type setter dest-type) `(named-lambda cp932-encoder (src start end dest d-start) (declare (type ,src-type src) (type ,dest-type dest) (fixnum start end d-start)) (loop with di fixnum = d-start for i fixnum from start below end for code of-type code-point = (,getter src i) for cp932 of-type code-point = (ucs-to-cp932 code) do (macrolet ((set-octet (offset value) `(,',setter ,value dest (the fixnum (+ di ,offset))))) (cond ;; 1 octet ((< cp932 #x100) (set-octet 0 cp932) (incf di)) ;; 2 octets ((< cp932 #x10000) (set-octet 0 (f-logand #xff (f-ash cp932 -8))) (set-octet 1 (logand cp932 #xff)) (incf di 2)) ;; 3 octets (t (set-octet 0 (f-logand #xff (f-ash cp932 -16))) (set-octet 1 (f-logand #xff (f-ash cp932 -8))) (set-octet 2 (logand cp932 #xff)) (incf di 3)) )) finally (return (the fixnum (- di d-start)))))) (define-decoder :cp932 (getter src-type setter dest-type) `(named-lambda cp932-decoder (src start end dest d-start) (declare (type ,src-type src) (type ,dest-type dest) (fixnum start end d-start)) (let ((u2 0)) (declare (type ub8 u2)) (loop for di fixnum from d-start for i fixnum from start below end for u1 of-type ub8 = (,getter src i) do ;; Note: CONSUME-OCTET doesn't check if I is being ;; incremented past END. We're assuming that END has ;; been calculated with the CODE-POINT-POINTER above that ;; checks this. (macrolet ((consume-octet () `(let ((next-i (incf i))) (if (= next-i end) ;; FIXME: data for this error is incomplete. ;; and signalling this error twice (return-from setter-block (decoding-error nil :cp932 src i +repl+ 'end-of-input-in-character)) (,',getter src next-i)))) (handle-error (n &optional (c 'character-decoding-error)) `(decoding-error (vector ,@(subseq '(u1 u2) 0 n)) :cp932 src (1+ (- i ,n)) +repl+ ',c)) (handle-error-if-icb (var n) `(when (not (< #x7f ,var #xc0)) (decf i) (return-from setter-block (handle-error ,n invalid-utf8-continuation-byte))))) (,setter (block setter-block (cond ;; 2 octets ((or (<= #x81 u1 #x9f) (<= #xe0 u1 #xfc)) (setq u2 (consume-octet)) (cp932-to-ucs (logior (f-ash u1 8) u2))) ;; 1 octet (t (cp932-to-ucs u1)))) dest di)) finally (return (the fixnum (- di d-start)))))))

Common Lisp

.lisp

cac-t-u-s/om-sharp

GPL-3.0

9/19/2024, 11:25:22 AM (Europe/Amsterdam)

69b1f21c2b07baf168ffb53b968a3fb7f1f15aaa2d49493556e82f750c4837fb

gbk-map.lisp

cac-t-u-s_om-sharp/src/api/foreign-interface/ffi/babel/src/gbk-map.lisp

;;;; -*- Mode: lisp; indent-tabs-mode: nil -*- ;;; ;;; gbk-map.lisp --- GBK encoding map. ;;; ;;; Copyright (C) 2011, Li Wenpeng <[email protected]> ;;; ;;; Permission is hereby granted, free of charge, to any person ;;; obtaining a copy of this software and associated documentation ;;; files (the "Software"), to deal in the Software without ;;; restriction, including without limitation the rights to use, copy, ;;; modify, merge, publish, distribute, sublicense, and/or sell copies ;;; of the Software, and to permit persons to whom the Software is ;;; furnished to do so, subject to the following conditions: ;;; ;;; The above copyright notice and this permission notice shall be ;;; included in all copies or substantial portions of the Software. ;;; ;;; THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, ;;; EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF ;;; MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND ;;; NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT ;;; HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, ;;; WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, ;;; OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER ;;; DEALINGS IN THE SOFTWARE. (in-package #:babel-encodings) (defparameter *gbk-unicode-mapping* (map 'babel:unicode-string #'code-char '(#x554A #x963F #x57C3 #x6328 #x54CE #x5509 #x54C0 #x7691 #x764C #x853C #x77EE #x827E #x788D #x7231 #x9698 #x978D #x6C28 #x5B89 #x4FFA #x6309 #x6697 #x5CB8 #x80FA #x6848 #x80AE #x6602 #x76CE #x51F9 #x6556 #x71AC #x7FF1 #x8884 #x50B2 #x5965 #x61CA #x6FB3 #x82AD #x634C #x6252 #x53ED #x5427 #x7B06 #x516B #x75A4 #x5DF4 #x62D4 #x8DCB #x9776 #x628A #x8019 #x575D #x9738 #x7F62 #x7238 #x767D #x67CF #x767E #x6446 #x4F70 #x8D25 #x62DC #x7A17 #x6591 #x73ED #x642C #x6273 #x822C #x9881 #x677F #x7248 #x626E #x62CC #x4F34 #x74E3 #x534A #x529E #x7ECA #x90A6 #x5E2E #x6886 #x699C #x8180 #x7ED1 #x68D2 #x78C5 #x868C #x9551 #x508D #x8C24 #x82DE #x80DE #x5305 #x8912 #x5265 #x8584 #x96F9 #x4FDD #x5821 #x9971 #x5B9D #x62B1 #x62A5 #x66B4 #x8C79 #x9C8D #x7206 #x676F #x7891 #x60B2 #x5351 #x5317 #x8F88 #x80CC #x8D1D #x94A1 #x500D #x72C8 #x5907 #x60EB #x7119 #x88AB #x5954 #x82EF #x672C #x7B28 #x5D29 #x7EF7 #x752D #x6CF5 #x8E66 #x8FF8 #x903C #x9F3B #x6BD4 #x9119 #x7B14 #x5F7C #x78A7 #x84D6 #x853D #x6BD5 #x6BD9 #x6BD6 #x5E01 #x5E87 #x75F9 #x95ED #x655D #x5F0A #x5FC5 #x8F9F #x58C1 #x81C2 #x907F #x965B #x97AD #x8FB9 #x7F16 #x8D2C #x6241 #x4FBF #x53D8 #x535E #x8FA8 #x8FA9 #x8FAB #x904D #x6807 #x5F6A #x8198 #x8868 #x9CD6 #x618B #x522B #x762A #x5F6C #x658C #x6FD2 #x6EE8 #x5BBE #x6448 #x5175 #x51B0 #x67C4 #x4E19 #x79C9 #x997C #x70B3 #x75C5 #x5E76 #x73BB #x83E0 #x64AD #x62E8 #x94B5 #x6CE2 #x535A #x52C3 #x640F #x94C2 #x7B94 #x4F2F #x5E1B #x8236 #x8116 #x818A #x6E24 #x6CCA #x9A73 #x6355 #x535C #x54FA #x8865 #x57E0 #x4E0D #x5E03 #x6B65 #x7C3F #x90E8 #x6016 #x64E6 #x731C #x88C1 #x6750 #x624D #x8D22 #x776C #x8E29 #x91C7 #x5F69 #x83DC #x8521 #x9910 #x53C2 #x8695 #x6B8B #x60ED #x60E8 #x707F #x82CD #x8231 #x4ED3 #x6CA7 #x85CF #x64CD #x7CD9 #x69FD #x66F9 #x8349 #x5395 #x7B56 #x4FA7 #x518C #x6D4B #x5C42 #x8E6D #x63D2 #x53C9 #x832C #x8336 #x67E5 #x78B4 #x643D #x5BDF #x5C94 #x5DEE #x8BE7 #x62C6 #x67F4 #x8C7A #x6400 #x63BA #x8749 #x998B #x8C17 #x7F20 #x94F2 #x4EA7 #x9610 #x98A4 #x660C #x7316 #x573A #x5C1D #x5E38 #x957F #x507F #x80A0 #x5382 #x655E #x7545 #x5531 #x5021 #x8D85 #x6284 #x949E #x671D #x5632 #x6F6E #x5DE2 #x5435 #x7092 #x8F66 #x626F #x64A4 #x63A3 #x5F7B #x6F88 #x90F4 #x81E3 #x8FB0 #x5C18 #x6668 #x5FF1 #x6C89 #x9648 #x8D81 #x886C #x6491 #x79F0 #x57CE #x6A59 #x6210 #x5448 #x4E58 #x7A0B #x60E9 #x6F84 #x8BDA #x627F #x901E #x9A8B #x79E4 #x5403 #x75F4 #x6301 #x5319 #x6C60 #x8FDF #x5F1B #x9A70 #x803B #x9F7F #x4F88 #x5C3A #x8D64 #x7FC5 #x65A5 #x70BD #x5145 #x51B2 #x866B #x5D07 #x5BA0 #x62BD #x916C #x7574 #x8E0C #x7A20 #x6101 #x7B79 #x4EC7 #x7EF8 #x7785 #x4E11 #x81ED #x521D #x51FA #x6A71 #x53A8 #x8E87 #x9504 #x96CF #x6EC1 #x9664 #x695A #x7840 #x50A8 #x77D7 #x6410 #x89E6 #x5904 #x63E3 #x5DDD #x7A7F #x693D #x4F20 #x8239 #x5598 #x4E32 #x75AE #x7A97 #x5E62 #x5E8A #x95EF #x521B #x5439 #x708A #x6376 #x9524 #x5782 #x6625 #x693F #x9187 #x5507 #x6DF3 #x7EAF #x8822 #x6233 #x7EF0 #x75B5 #x8328 #x78C1 #x96CC #x8F9E #x6148 #x74F7 #x8BCD #x6B64 #x523A #x8D50 #x6B21 #x806A #x8471 #x56F1 #x5306 #x4ECE #x4E1B #x51D1 #x7C97 #x918B #x7C07 #x4FC3 #x8E7F #x7BE1 #x7A9C #x6467 #x5D14 #x50AC #x8106 #x7601 #x7CB9 #x6DEC #x7FE0 #x6751 #x5B58 #x5BF8 #x78CB #x64AE #x6413 #x63AA #x632B #x9519 #x642D #x8FBE #x7B54 #x7629 #x6253 #x5927 #x5446 #x6B79 #x50A3 #x6234 #x5E26 #x6B86 #x4EE3 #x8D37 #x888B #x5F85 #x902E #x6020 #x803D #x62C5 #x4E39 #x5355 #x90F8 #x63B8 #x80C6 #x65E6 #x6C2E #x4F46 #x60EE #x6DE1 #x8BDE #x5F39 #x86CB #x5F53 #x6321 #x515A #x8361 #x6863 #x5200 #x6363 #x8E48 #x5012 #x5C9B #x7977 #x5BFC #x5230 #x7A3B #x60BC #x9053 #x76D7 #x5FB7 #x5F97 #x7684 #x8E6C #x706F #x767B #x7B49 #x77AA #x51F3 #x9093 #x5824 #x4F4E #x6EF4 #x8FEA #x654C #x7B1B #x72C4 #x6DA4 #x7FDF #x5AE1 #x62B5 #x5E95 #x5730 #x8482 #x7B2C #x5E1D #x5F1F #x9012 #x7F14 #x98A0 #x6382 #x6EC7 #x7898 #x70B9 #x5178 #x975B #x57AB #x7535 #x4F43 #x7538 #x5E97 #x60E6 #x5960 #x6DC0 #x6BBF #x7889 #x53FC #x96D5 #x51CB #x5201 #x6389 #x540A #x9493 #x8C03 #x8DCC #x7239 #x789F #x8776 #x8FED #x8C0D #x53E0 #x4E01 #x76EF #x53EE #x9489 #x9876 #x9F0E #x952D #x5B9A #x8BA2 #x4E22 #x4E1C #x51AC #x8463 #x61C2 #x52A8 #x680B #x4F97 #x606B #x51BB #x6D1E #x515C #x6296 #x6597 #x9661 #x8C46 #x9017 #x75D8 #x90FD #x7763 #x6BD2 #x728A #x72EC #x8BFB #x5835 #x7779 #x8D4C #x675C #x9540 #x809A #x5EA6 #x6E21 #x5992 #x7AEF #x77ED #x953B #x6BB5 #x65AD #x7F0E #x5806 #x5151 #x961F #x5BF9 #x58A9 #x5428 #x8E72 #x6566 #x987F #x56E4 #x949D #x76FE #x9041 #x6387 #x54C6 #x591A #x593A #x579B #x8EB2 #x6735 #x8DFA #x8235 #x5241 #x60F0 #x5815 #x86FE #x5CE8 #x9E45 #x4FC4 #x989D #x8BB9 #x5A25 #x6076 #x5384 #x627C #x904F #x9102 #x997F #x6069 #x800C #x513F #x8033 #x5C14 #x9975 #x6D31 #x4E8C #x8D30 #x53D1 #x7F5A #x7B4F #x4F10 #x4E4F #x9600 #x6CD5 #x73D0 #x85E9 #x5E06 #x756A #x7FFB #x6A0A #x77FE #x9492 #x7E41 #x51E1 #x70E6 #x53CD #x8FD4 #x8303 #x8D29 #x72AF #x996D #x6CDB #x574A #x82B3 #x65B9 #x80AA #x623F #x9632 #x59A8 #x4EFF #x8BBF #x7EBA #x653E #x83F2 #x975E #x5561 #x98DE #x80A5 #x532A #x8BFD #x5420 #x80BA #x5E9F #x6CB8 #x8D39 #x82AC #x915A #x5429 #x6C1B #x5206 #x7EB7 #x575F #x711A #x6C7E #x7C89 #x594B #x4EFD #x5FFF #x6124 #x7CAA #x4E30 #x5C01 #x67AB #x8702 #x5CF0 #x950B #x98CE #x75AF #x70FD #x9022 #x51AF #x7F1D #x8BBD #x5949 #x51E4 #x4F5B #x5426 #x592B #x6577 #x80A4 #x5B75 #x6276 #x62C2 #x8F90 #x5E45 #x6C1F #x7B26 #x4F0F #x4FD8 #x670D #x6D6E #x6DAA #x798F #x88B1 #x5F17 #x752B #x629A #x8F85 #x4FEF #x91DC #x65A7 #x812F #x8151 #x5E9C #x8150 #x8D74 #x526F #x8986 #x8D4B #x590D #x5085 #x4ED8 #x961C #x7236 #x8179 #x8D1F #x5BCC #x8BA3 #x9644 #x5987 #x7F1A #x5490 #x5676 #x560E #x8BE5 #x6539 #x6982 #x9499 #x76D6 #x6E89 #x5E72 #x7518 #x6746 #x67D1 #x7AFF #x809D #x8D76 #x611F #x79C6 #x6562 #x8D63 #x5188 #x521A #x94A2 #x7F38 #x809B #x7EB2 #x5C97 #x6E2F #x6760 #x7BD9 #x768B #x9AD8 #x818F #x7F94 #x7CD5 #x641E #x9550 #x7A3F #x544A #x54E5 #x6B4C #x6401 #x6208 #x9E3D #x80F3 #x7599 #x5272 #x9769 #x845B #x683C #x86E4 #x9601 #x9694 #x94EC #x4E2A #x5404 #x7ED9 #x6839 #x8DDF #x8015 #x66F4 #x5E9A #x7FB9 #x57C2 #x803F #x6897 #x5DE5 #x653B #x529F #x606D #x9F9A #x4F9B #x8EAC #x516C #x5BAB #x5F13 #x5DE9 #x6C5E #x62F1 #x8D21 #x5171 #x94A9 #x52FE #x6C9F #x82DF #x72D7 #x57A2 #x6784 #x8D2D #x591F #x8F9C #x83C7 #x5495 #x7B8D #x4F30 #x6CBD #x5B64 #x59D1 #x9F13 #x53E4 #x86CA #x9AA8 #x8C37 #x80A1 #x6545 #x987E #x56FA #x96C7 #x522E #x74DC #x5250 #x5BE1 #x6302 #x8902 #x4E56 #x62D0 #x602A #x68FA #x5173 #x5B98 #x51A0 #x89C2 #x7BA1 #x9986 #x7F50 #x60EF #x704C #x8D2F #x5149 #x5E7F #x901B #x7470 #x89C4 #x572D #x7845 #x5F52 #x9F9F #x95FA #x8F68 #x9B3C #x8BE1 #x7678 #x6842 #x67DC #x8DEA #x8D35 #x523D #x8F8A #x6EDA #x68CD #x9505 #x90ED #x56FD #x679C #x88F9 #x8FC7 #x54C8 #x9AB8 #x5B69 #x6D77 #x6C26 #x4EA5 #x5BB3 #x9A87 #x9163 #x61A8 #x90AF #x97E9 #x542B #x6DB5 #x5BD2 #x51FD #x558A #x7F55 #x7FF0 #x64BC #x634D #x65F1 #x61BE #x608D #x710A #x6C57 #x6C49 #x592F #x676D #x822A #x58D5 #x568E #x8C6A #x6BEB #x90DD #x597D #x8017 #x53F7 #x6D69 #x5475 #x559D #x8377 #x83CF #x6838 #x79BE #x548C #x4F55 #x5408 #x76D2 #x8C89 #x9602 #x6CB3 #x6DB8 #x8D6B #x8910 #x9E64 #x8D3A #x563F #x9ED1 #x75D5 #x5F88 #x72E0 #x6068 #x54FC #x4EA8 #x6A2A #x8861 #x6052 #x8F70 #x54C4 #x70D8 #x8679 #x9E3F #x6D2A #x5B8F #x5F18 #x7EA2 #x5589 #x4FAF #x7334 #x543C #x539A #x5019 #x540E #x547C #x4E4E #x5FFD #x745A #x58F6 #x846B #x80E1 #x8774 #x72D0 #x7CCA #x6E56 #x5F27 #x864E #x552C #x62A4 #x4E92 #x6CAA #x6237 #x82B1 #x54D7 #x534E #x733E #x6ED1 #x753B #x5212 #x5316 #x8BDD #x69D0 #x5F8A #x6000 #x6DEE #x574F #x6B22 #x73AF #x6853 #x8FD8 #x7F13 #x6362 #x60A3 #x5524 #x75EA #x8C62 #x7115 #x6DA3 #x5BA6 #x5E7B #x8352 #x614C #x9EC4 #x78FA #x8757 #x7C27 #x7687 #x51F0 #x60F6 #x714C #x6643 #x5E4C #x604D #x8C0E #x7070 #x6325 #x8F89 #x5FBD #x6062 #x86D4 #x56DE #x6BC1 #x6094 #x6167 #x5349 #x60E0 #x6666 #x8D3F #x79FD #x4F1A #x70E9 #x6C47 #x8BB3 #x8BF2 #x7ED8 #x8364 #x660F #x5A5A #x9B42 #x6D51 #x6DF7 #x8C41 #x6D3B #x4F19 #x706B #x83B7 #x6216 #x60D1 #x970D #x8D27 #x7978 #x51FB #x573E #x57FA #x673A #x7578 #x7A3D #x79EF #x7B95 #x808C #x9965 #x8FF9 #x6FC0 #x8BA5 #x9E21 #x59EC #x7EE9 #x7F09 #x5409 #x6781 #x68D8 #x8F91 #x7C4D #x96C6 #x53CA #x6025 #x75BE #x6C72 #x5373 #x5AC9 #x7EA7 #x6324 #x51E0 #x810A #x5DF1 #x84DF #x6280 #x5180 #x5B63 #x4F0E #x796D #x5242 #x60B8 #x6D4E #x5BC4 #x5BC2 #x8BA1 #x8BB0 #x65E2 #x5FCC #x9645 #x5993 #x7EE7 #x7EAA #x5609 #x67B7 #x5939 #x4F73 #x5BB6 #x52A0 #x835A #x988A #x8D3E #x7532 #x94BE #x5047 #x7A3C #x4EF7 #x67B6 #x9A7E #x5AC1 #x6B7C #x76D1 #x575A #x5C16 #x7B3A #x95F4 #x714E #x517C #x80A9 #x8270 #x5978 #x7F04 #x8327 #x68C0 #x67EC #x78B1 #x7877 #x62E3 #x6361 #x7B80 #x4FED #x526A #x51CF #x8350 #x69DB #x9274 #x8DF5 #x8D31 #x89C1 #x952E #x7BAD #x4EF6 #x5065 #x8230 #x5251 #x996F #x6E10 #x6E85 #x6DA7 #x5EFA #x50F5 #x59DC #x5C06 #x6D46 #x6C5F #x7586 #x848B #x6868 #x5956 #x8BB2 #x5320 #x9171 #x964D #x8549 #x6912 #x7901 #x7126 #x80F6 #x4EA4 #x90CA #x6D47 #x9A84 #x5A07 #x56BC #x6405 #x94F0 #x77EB #x4FA5 #x811A #x72E1 #x89D2 #x997A #x7F34 #x7EDE #x527F #x6559 #x9175 #x8F7F #x8F83 #x53EB #x7A96 #x63ED #x63A5 #x7686 #x79F8 #x8857 #x9636 #x622A #x52AB #x8282 #x6854 #x6770 #x6377 #x776B #x7AED #x6D01 #x7ED3 #x89E3 #x59D0 #x6212 #x85C9 #x82A5 #x754C #x501F #x4ECB #x75A5 #x8BEB #x5C4A #x5DFE #x7B4B #x65A4 #x91D1 #x4ECA #x6D25 #x895F #x7D27 #x9526 #x4EC5 #x8C28 #x8FDB #x9773 #x664B #x7981 #x8FD1 #x70EC #x6D78 #x5C3D #x52B2 #x8346 #x5162 #x830E #x775B #x6676 #x9CB8 #x4EAC #x60CA #x7CBE #x7CB3 #x7ECF #x4E95 #x8B66 #x666F #x9888 #x9759 #x5883 #x656C #x955C #x5F84 #x75C9 #x9756 #x7ADF #x7ADE #x51C0 #x70AF #x7A98 #x63EA #x7A76 #x7EA0 #x7396 #x97ED #x4E45 #x7078 #x4E5D #x9152 #x53A9 #x6551 #x65E7 #x81FC #x8205 #x548E #x5C31 #x759A #x97A0 #x62D8 #x72D9 #x75BD #x5C45 #x9A79 #x83CA #x5C40 #x5480 #x77E9 #x4E3E #x6CAE #x805A #x62D2 #x636E #x5DE8 #x5177 #x8DDD #x8E1E #x952F #x4FF1 #x53E5 #x60E7 #x70AC #x5267 #x6350 #x9E43 #x5A1F #x5026 #x7737 #x5377 #x7EE2 #x6485 #x652B #x6289 #x6398 #x5014 #x7235 #x89C9 #x51B3 #x8BC0 #x7EDD #x5747 #x83CC #x94A7 #x519B #x541B #x5CFB #x4FCA #x7AE3 #x6D5A #x90E1 #x9A8F #x5580 #x5496 #x5361 #x54AF #x5F00 #x63E9 #x6977 #x51EF #x6168 #x520A #x582A #x52D8 #x574E #x780D #x770B #x5EB7 #x6177 #x7CE0 #x625B #x6297 #x4EA2 #x7095 #x8003 #x62F7 #x70E4 #x9760 #x5777 #x82DB #x67EF #x68F5 #x78D5 #x9897 #x79D1 #x58F3 #x54B3 #x53EF #x6E34 #x514B #x523B #x5BA2 #x8BFE #x80AF #x5543 #x57A6 #x6073 #x5751 #x542D #x7A7A #x6050 #x5B54 #x63A7 #x62A0 #x53E3 #x6263 #x5BC7 #x67AF #x54ED #x7A9F #x82E6 #x9177 #x5E93 #x88E4 #x5938 #x57AE #x630E #x8DE8 #x80EF #x5757 #x7B77 #x4FA9 #x5FEB #x5BBD #x6B3E #x5321 #x7B50 #x72C2 #x6846 #x77FF #x7736 #x65F7 #x51B5 #x4E8F #x76D4 #x5CBF #x7AA5 #x8475 #x594E #x9B41 #x5080 #x9988 #x6127 #x6E83 #x5764 #x6606 #x6346 #x56F0 #x62EC #x6269 #x5ED3 #x9614 #x5783 #x62C9 #x5587 #x8721 #x814A #x8FA3 #x5566 #x83B1 #x6765 #x8D56 #x84DD #x5A6A #x680F #x62E6 #x7BEE #x9611 #x5170 #x6F9C #x8C30 #x63FD #x89C8 #x61D2 #x7F06 #x70C2 #x6EE5 #x7405 #x6994 #x72FC #x5ECA #x90CE #x6717 #x6D6A #x635E #x52B3 #x7262 #x8001 #x4F6C #x59E5 #x916A #x70D9 #x6D9D #x52D2 #x4E50 #x96F7 #x956D #x857E #x78CA #x7D2F #x5121 #x5792 #x64C2 #x808B #x7C7B #x6CEA #x68F1 #x695E #x51B7 #x5398 #x68A8 #x7281 #x9ECE #x7BF1 #x72F8 #x79BB #x6F13 #x7406 #x674E #x91CC #x9CA4 #x793C #x8389 #x8354 #x540F #x6817 #x4E3D #x5389 #x52B1 #x783E #x5386 #x5229 #x5088 #x4F8B #x4FD0 #x75E2 #x7ACB #x7C92 #x6CA5 #x96B6 #x529B #x7483 #x54E9 #x4FE9 #x8054 #x83B2 #x8FDE #x9570 #x5EC9 #x601C #x6D9F #x5E18 #x655B #x8138 #x94FE #x604B #x70BC #x7EC3 #x7CAE #x51C9 #x6881 #x7CB1 #x826F #x4E24 #x8F86 #x91CF #x667E #x4EAE #x8C05 #x64A9 #x804A #x50DA #x7597 #x71CE #x5BE5 #x8FBD #x6F66 #x4E86 #x6482 #x9563 #x5ED6 #x6599 #x5217 #x88C2 #x70C8 #x52A3 #x730E #x7433 #x6797 #x78F7 #x9716 #x4E34 #x90BB #x9CDE #x6DCB #x51DB #x8D41 #x541D #x62CE #x73B2 #x83F1 #x96F6 #x9F84 #x94C3 #x4F36 #x7F9A #x51CC #x7075 #x9675 #x5CAD #x9886 #x53E6 #x4EE4 #x6E9C #x7409 #x69B4 #x786B #x998F #x7559 #x5218 #x7624 #x6D41 #x67F3 #x516D #x9F99 #x804B #x5499 #x7B3C #x7ABF #x9686 #x5784 #x62E2 #x9647 #x697C #x5A04 #x6402 #x7BD3 #x6F0F #x964B #x82A6 #x5362 #x9885 #x5E90 #x7089 #x63B3 #x5364 #x864F #x9C81 #x9E93 #x788C #x9732 #x8DEF #x8D42 #x9E7F #x6F5E #x7984 #x5F55 #x9646 #x622E #x9A74 #x5415 #x94DD #x4FA3 #x65C5 #x5C65 #x5C61 #x7F15 #x8651 #x6C2F #x5F8B #x7387 #x6EE4 #x7EFF #x5CE6 #x631B #x5B6A #x6EE6 #x5375 #x4E71 #x63A0 #x7565 #x62A1 #x8F6E #x4F26 #x4ED1 #x6CA6 #x7EB6 #x8BBA #x841D #x87BA #x7F57 #x903B #x9523 #x7BA9 #x9AA1 #x88F8 #x843D #x6D1B #x9A86 #x7EDC #x5988 #x9EBB #x739B #x7801 #x8682 #x9A6C #x9A82 #x561B #x5417 #x57CB #x4E70 #x9EA6 #x5356 #x8FC8 #x8109 #x7792 #x9992 #x86EE #x6EE1 #x8513 #x66FC #x6162 #x6F2B #x8C29 #x8292 #x832B #x76F2 #x6C13 #x5FD9 #x83BD #x732B #x8305 #x951A #x6BDB #x77DB #x94C6 #x536F #x8302 #x5192 #x5E3D #x8C8C #x8D38 #x4E48 #x73AB #x679A #x6885 #x9176 #x9709 #x7164 #x6CA1 #x7709 #x5A92 #x9541 #x6BCF #x7F8E #x6627 #x5BD0 #x59B9 #x5A9A #x95E8 #x95F7 #x4EEC #x840C #x8499 #x6AAC #x76DF #x9530 #x731B #x68A6 #x5B5F #x772F #x919A #x9761 #x7CDC #x8FF7 #x8C1C #x5F25 #x7C73 #x79D8 #x89C5 #x6CCC #x871C #x5BC6 #x5E42 #x68C9 #x7720 #x7EF5 #x5195 #x514D #x52C9 #x5A29 #x7F05 #x9762 #x82D7 #x63CF #x7784 #x85D0 #x79D2 #x6E3A #x5E99 #x5999 #x8511 #x706D #x6C11 #x62BF #x76BF #x654F #x60AF #x95FD #x660E #x879F #x9E23 #x94ED #x540D #x547D #x8C2C #x6478 #x6479 #x8611 #x6A21 #x819C #x78E8 #x6469 #x9B54 #x62B9 #x672B #x83AB #x58A8 #x9ED8 #x6CAB #x6F20 #x5BDE #x964C #x8C0B #x725F #x67D0 #x62C7 #x7261 #x4EA9 #x59C6 #x6BCD #x5893 #x66AE #x5E55 #x52DF #x6155 #x6728 #x76EE #x7766 #x7267 #x7A46 #x62FF #x54EA #x5450 #x94A0 #x90A3 #x5A1C #x7EB3 #x6C16 #x4E43 #x5976 #x8010 #x5948 #x5357 #x7537 #x96BE #x56CA #x6320 #x8111 #x607C #x95F9 #x6DD6 #x5462 #x9981 #x5185 #x5AE9 #x80FD #x59AE #x9713 #x502A #x6CE5 #x5C3C #x62DF #x4F60 #x533F #x817B #x9006 #x6EBA #x852B #x62C8 #x5E74 #x78BE #x64B5 #x637B #x5FF5 #x5A18 #x917F #x9E1F #x5C3F #x634F #x8042 #x5B7D #x556E #x954A #x954D #x6D85 #x60A8 #x67E0 #x72DE #x51DD #x5B81 #x62E7 #x6CDE #x725B #x626D #x94AE #x7EBD #x8113 #x6D53 #x519C #x5F04 #x5974 #x52AA #x6012 #x5973 #x6696 #x8650 #x759F #x632A #x61E6 #x7CEF #x8BFA #x54E6 #x6B27 #x9E25 #x6BB4 #x85D5 #x5455 #x5076 #x6CA4 #x556A #x8DB4 #x722C #x5E15 #x6015 #x7436 #x62CD #x6392 #x724C #x5F98 #x6E43 #x6D3E #x6500 #x6F58 #x76D8 #x78D0 #x76FC #x7554 #x5224 #x53DB #x4E53 #x5E9E #x65C1 #x802A #x80D6 #x629B #x5486 #x5228 #x70AE #x888D #x8DD1 #x6CE1 #x5478 #x80DA #x57F9 #x88F4 #x8D54 #x966A #x914D #x4F69 #x6C9B #x55B7 #x76C6 #x7830 #x62A8 #x70F9 #x6F8E #x5F6D #x84EC #x68DA #x787C #x7BF7 #x81A8 #x670B #x9E4F #x6367 #x78B0 #x576F #x7812 #x9739 #x6279 #x62AB #x5288 #x7435 #x6BD7 #x5564 #x813E #x75B2 #x76AE #x5339 #x75DE #x50FB #x5C41 #x8B6C #x7BC7 #x504F #x7247 #x9A97 #x98D8 #x6F02 #x74E2 #x7968 #x6487 #x77A5 #x62FC #x9891 #x8D2B #x54C1 #x8058 #x4E52 #x576A #x82F9 #x840D #x5E73 #x51ED #x74F6 #x8BC4 #x5C4F #x5761 #x6CFC #x9887 #x5A46 #x7834 #x9B44 #x8FEB #x7C95 #x5256 #x6251 #x94FA #x4EC6 #x8386 #x8461 #x83E9 #x84B2 #x57D4 #x6734 #x5703 #x666E #x6D66 #x8C31 #x66DD #x7011 #x671F #x6B3A #x6816 #x621A #x59BB #x4E03 #x51C4 #x6F06 #x67D2 #x6C8F #x5176 #x68CB #x5947 #x6B67 #x7566 #x5D0E #x8110 #x9F50 #x65D7 #x7948 #x7941 #x9A91 #x8D77 #x5C82 #x4E5E #x4F01 #x542F #x5951 #x780C #x5668 #x6C14 #x8FC4 #x5F03 #x6C7D #x6CE3 #x8BAB #x6390 #x6070 #x6D3D #x7275 #x6266 #x948E #x94C5 #x5343 #x8FC1 #x7B7E #x4EDF #x8C26 #x4E7E #x9ED4 #x94B1 #x94B3 #x524D #x6F5C #x9063 #x6D45 #x8C34 #x5811 #x5D4C #x6B20 #x6B49 #x67AA #x545B #x8154 #x7F8C #x5899 #x8537 #x5F3A #x62A2 #x6A47 #x9539 #x6572 #x6084 #x6865 #x77A7 #x4E54 #x4FA8 #x5DE7 #x9798 #x64AC #x7FD8 #x5CED #x4FCF #x7A8D #x5207 #x8304 #x4E14 #x602F #x7A83 #x94A6 #x4FB5 #x4EB2 #x79E6 #x7434 #x52E4 #x82B9 #x64D2 #x79BD #x5BDD #x6C81 #x9752 #x8F7B #x6C22 #x503E #x537F #x6E05 #x64CE #x6674 #x6C30 #x60C5 #x9877 #x8BF7 #x5E86 #x743C #x7A77 #x79CB #x4E18 #x90B1 #x7403 #x6C42 #x56DA #x914B #x6CC5 #x8D8B #x533A #x86C6 #x66F2 #x8EAF #x5C48 #x9A71 #x6E20 #x53D6 #x5A36 #x9F8B #x8DA3 #x53BB #x5708 #x98A7 #x6743 #x919B #x6CC9 #x5168 #x75CA #x62F3 #x72AC #x5238 #x529D #x7F3A #x7094 #x7638 #x5374 #x9E4A #x69B7 #x786E #x96C0 #x88D9 #x7FA4 #x7136 #x71C3 #x5189 #x67D3 #x74E4 #x58E4 #x6518 #x56B7 #x8BA9 #x9976 #x6270 #x7ED5 #x60F9 #x70ED #x58EC #x4EC1 #x4EBA #x5FCD #x97E7 #x4EFB #x8BA4 #x5203 #x598A #x7EAB #x6254 #x4ECD #x65E5 #x620E #x8338 #x84C9 #x8363 #x878D #x7194 #x6EB6 #x5BB9 #x7ED2 #x5197 #x63C9 #x67D4 #x8089 #x8339 #x8815 #x5112 #x5B7A #x5982 #x8FB1 #x4E73 #x6C5D #x5165 #x8925 #x8F6F #x962E #x854A #x745E #x9510 #x95F0 #x6DA6 #x82E5 #x5F31 #x6492 #x6D12 #x8428 #x816E #x9CC3 #x585E #x8D5B #x4E09 #x53C1 #x4F1E #x6563 #x6851 #x55D3 #x4E27 #x6414 #x9A9A #x626B #x5AC2 #x745F #x8272 #x6DA9 #x68EE #x50E7 #x838E #x7802 #x6740 #x5239 #x6C99 #x7EB1 #x50BB #x5565 #x715E #x7B5B #x6652 #x73CA #x82EB #x6749 #x5C71 #x5220 #x717D #x886B #x95EA #x9655 #x64C5 #x8D61 #x81B3 #x5584 #x6C55 #x6247 #x7F2E #x5892 #x4F24 #x5546 #x8D4F #x664C #x4E0A #x5C1A #x88F3 #x68A2 #x634E #x7A0D #x70E7 #x828D #x52FA #x97F6 #x5C11 #x54E8 #x90B5 #x7ECD #x5962 #x8D4A #x86C7 #x820C #x820D #x8D66 #x6444 #x5C04 #x6151 #x6D89 #x793E #x8BBE #x7837 #x7533 #x547B #x4F38 #x8EAB #x6DF1 #x5A20 #x7EC5 #x795E #x6C88 #x5BA1 #x5A76 #x751A #x80BE #x614E #x6E17 #x58F0 #x751F #x7525 #x7272 #x5347 #x7EF3 #x7701 #x76DB #x5269 #x80DC #x5723 #x5E08 #x5931 #x72EE #x65BD #x6E7F #x8BD7 #x5C38 #x8671 #x5341 #x77F3 #x62FE #x65F6 #x4EC0 #x98DF #x8680 #x5B9E #x8BC6 #x53F2 #x77E2 #x4F7F #x5C4E #x9A76 #x59CB #x5F0F #x793A #x58EB #x4E16 #x67FF #x4E8B #x62ED #x8A93 #x901D #x52BF #x662F #x55DC #x566C #x9002 #x4ED5 #x4F8D #x91CA #x9970 #x6C0F #x5E02 #x6043 #x5BA4 #x89C6 #x8BD5 #x6536 #x624B #x9996 #x5B88 #x5BFF #x6388 #x552E #x53D7 #x7626 #x517D #x852C #x67A2 #x68B3 #x6B8A #x6292 #x8F93 #x53D4 #x8212 #x6DD1 #x758F #x4E66 #x8D4E #x5B70 #x719F #x85AF #x6691 #x66D9 #x7F72 #x8700 #x9ECD #x9F20 #x5C5E #x672F #x8FF0 #x6811 #x675F #x620D #x7AD6 #x5885 #x5EB6 #x6570 #x6F31 #x6055 #x5237 #x800D #x6454 #x8870 #x7529 #x5E05 #x6813 #x62F4 #x971C #x53CC #x723D #x8C01 #x6C34 #x7761 #x7A0E #x542E #x77AC #x987A #x821C #x8BF4 #x7855 #x6714 #x70C1 #x65AF #x6495 #x5636 #x601D #x79C1 #x53F8 #x4E1D #x6B7B #x8086 #x5BFA #x55E3 #x56DB #x4F3A #x4F3C #x9972 #x5DF3 #x677E #x8038 #x6002 #x9882 #x9001 #x5B8B #x8BBC #x8BF5 #x641C #x8258 #x64DE #x55FD #x82CF #x9165 #x4FD7 #x7D20 #x901F #x7C9F #x50F3 #x5851 #x6EAF #x5BBF #x8BC9 #x8083 #x9178 #x849C #x7B97 #x867D #x968B #x968F #x7EE5 #x9AD3 #x788E #x5C81 #x7A57 #x9042 #x96A7 #x795F #x5B59 #x635F #x7B0B #x84D1 #x68AD #x5506 #x7F29 #x7410 #x7D22 #x9501 #x6240 #x584C #x4ED6 #x5B83 #x5979 #x5854 #x736D #x631E #x8E4B #x8E0F #x80CE #x82D4 #x62AC #x53F0 #x6CF0 #x915E #x592A #x6001 #x6C70 #x574D #x644A #x8D2A #x762B #x6EE9 #x575B #x6A80 #x75F0 #x6F6D #x8C2D #x8C08 #x5766 #x6BEF #x8892 #x78B3 #x63A2 #x53F9 #x70AD #x6C64 #x5858 #x642A #x5802 #x68E0 #x819B #x5510 #x7CD6 #x5018 #x8EBA #x6DCC #x8D9F #x70EB #x638F #x6D9B #x6ED4 #x7EE6 #x8404 #x6843 #x9003 #x6DD8 #x9676 #x8BA8 #x5957 #x7279 #x85E4 #x817E #x75BC #x8A8A #x68AF #x5254 #x8E22 #x9511 #x63D0 #x9898 #x8E44 #x557C #x4F53 #x66FF #x568F #x60D5 #x6D95 #x5243 #x5C49 #x5929 #x6DFB #x586B #x7530 #x751C #x606C #x8214 #x8146 #x6311 #x6761 #x8FE2 #x773A #x8DF3 #x8D34 #x94C1 #x5E16 #x5385 #x542C #x70C3 #x6C40 #x5EF7 #x505C #x4EAD #x5EAD #x633A #x8247 #x901A #x6850 #x916E #x77B3 #x540C #x94DC #x5F64 #x7AE5 #x6876 #x6345 #x7B52 #x7EDF #x75DB #x5077 #x6295 #x5934 #x900F #x51F8 #x79C3 #x7A81 #x56FE #x5F92 #x9014 #x6D82 #x5C60 #x571F #x5410 #x5154 #x6E4D #x56E2 #x63A8 #x9893 #x817F #x8715 #x892A #x9000 #x541E #x5C6F #x81C0 #x62D6 #x6258 #x8131 #x9E35 #x9640 #x9A6E #x9A7C #x692D #x59A5 #x62D3 #x553E #x6316 #x54C7 #x86D9 #x6D3C #x5A03 #x74E6 #x889C #x6B6A #x5916 #x8C4C #x5F2F #x6E7E #x73A9 #x987D #x4E38 #x70F7 #x5B8C #x7897 #x633D #x665A #x7696 #x60CB #x5B9B #x5A49 #x4E07 #x8155 #x6C6A #x738B #x4EA1 #x6789 #x7F51 #x5F80 #x65FA #x671B #x5FD8 #x5984 #x5A01 #x5DCD #x5FAE #x5371 #x97E6 #x8FDD #x6845 #x56F4 #x552F #x60DF #x4E3A #x6F4D #x7EF4 #x82C7 #x840E #x59D4 #x4F1F #x4F2A #x5C3E #x7EAC #x672A #x851A #x5473 #x754F #x80C3 #x5582 #x9B4F #x4F4D #x6E2D #x8C13 #x5C09 #x6170 #x536B #x761F #x6E29 #x868A #x6587 #x95FB #x7EB9 #x543B #x7A33 #x7D0A #x95EE #x55E1 #x7FC1 #x74EE #x631D #x8717 #x6DA1 #x7A9D #x6211 #x65A1 #x5367 #x63E1 #x6C83 #x5DEB #x545C #x94A8 #x4E4C #x6C61 #x8BEC #x5C4B #x65E0 #x829C #x68A7 #x543E #x5434 #x6BCB #x6B66 #x4E94 #x6342 #x5348 #x821E #x4F0D #x4FAE #x575E #x620A #x96FE #x6664 #x7269 #x52FF #x52A1 #x609F #x8BEF #x6614 #x7199 #x6790 #x897F #x7852 #x77FD #x6670 #x563B #x5438 #x9521 #x727A #x7A00 #x606F #x5E0C #x6089 #x819D #x5915 #x60DC #x7184 #x70EF #x6EAA #x6C50 #x7280 #x6A84 #x88AD #x5E2D #x4E60 #x5AB3 #x559C #x94E3 #x6D17 #x7CFB #x9699 #x620F #x7EC6 #x778E #x867E #x5323 #x971E #x8F96 #x6687 #x5CE1 #x4FA0 #x72ED #x4E0B #x53A6 #x590F #x5413 #x6380 #x9528 #x5148 #x4ED9 #x9C9C #x7EA4 #x54B8 #x8D24 #x8854 #x8237 #x95F2 #x6D8E #x5F26 #x5ACC #x663E #x9669 #x73B0 #x732E #x53BF #x817A #x9985 #x7FA1 #x5BAA #x9677 #x9650 #x7EBF #x76F8 #x53A2 #x9576 #x9999 #x7BB1 #x8944 #x6E58 #x4E61 #x7FD4 #x7965 #x8BE6 #x60F3 #x54CD #x4EAB #x9879 #x5DF7 #x6A61 #x50CF #x5411 #x8C61 #x8427 #x785D #x9704 #x524A #x54EE #x56A3 #x9500 #x6D88 #x5BB5 #x6DC6 #x6653 #x5C0F #x5B5D #x6821 #x8096 #x5578 #x7B11 #x6548 #x6954 #x4E9B #x6B47 #x874E #x978B #x534F #x631F #x643A #x90AA #x659C #x80C1 #x8C10 #x5199 #x68B0 #x5378 #x87F9 #x61C8 #x6CC4 #x6CFB #x8C22 #x5C51 #x85AA #x82AF #x950C #x6B23 #x8F9B #x65B0 #x5FFB #x5FC3 #x4FE1 #x8845 #x661F #x8165 #x7329 #x60FA #x5174 #x5211 #x578B #x5F62 #x90A2 #x884C #x9192 #x5E78 #x674F #x6027 #x59D3 #x5144 #x51F6 #x80F8 #x5308 #x6C79 #x96C4 #x718A #x4F11 #x4FEE #x7F9E #x673D #x55C5 #x9508 #x79C0 #x8896 #x7EE3 #x589F #x620C #x9700 #x865A #x5618 #x987B #x5F90 #x8BB8 #x84C4 #x9157 #x53D9 #x65ED #x5E8F #x755C #x6064 #x7D6E #x5A7F #x7EEA #x7EED #x8F69 #x55A7 #x5BA3 #x60AC #x65CB #x7384 #x9009 #x7663 #x7729 #x7EDA #x9774 #x859B #x5B66 #x7A74 #x96EA #x8840 #x52CB #x718F #x5FAA #x65EC #x8BE2 #x5BFB #x9A6F #x5DE1 #x6B89 #x6C5B #x8BAD #x8BAF #x900A #x8FC5 #x538B #x62BC #x9E26 #x9E2D #x5440 #x4E2B #x82BD #x7259 #x869C #x5D16 #x8859 #x6DAF #x96C5 #x54D1 #x4E9A #x8BB6 #x7109 #x54BD #x9609 #x70DF #x6DF9 #x76D0 #x4E25 #x7814 #x8712 #x5CA9 #x5EF6 #x8A00 #x989C #x960E #x708E #x6CBF #x5944 #x63A9 #x773C #x884D #x6F14 #x8273 #x5830 #x71D5 #x538C #x781A #x96C1 #x5501 #x5F66 #x7130 #x5BB4 #x8C1A #x9A8C #x6B83 #x592E #x9E2F #x79E7 #x6768 #x626C #x4F6F #x75A1 #x7F8A #x6D0B #x9633 #x6C27 #x4EF0 #x75D2 #x517B #x6837 #x6F3E #x9080 #x8170 #x5996 #x7476 #x6447 #x5C27 #x9065 #x7A91 #x8C23 #x59DA #x54AC #x8200 #x836F #x8981 #x8000 #x6930 #x564E #x8036 #x7237 #x91CE #x51B6 #x4E5F #x9875 #x6396 #x4E1A #x53F6 #x66F3 #x814B #x591C #x6DB2 #x4E00 #x58F9 #x533B #x63D6 #x94F1 #x4F9D #x4F0A #x8863 #x9890 #x5937 #x9057 #x79FB #x4EEA #x80F0 #x7591 #x6C82 #x5B9C #x59E8 #x5F5D #x6905 #x8681 #x501A #x5DF2 #x4E59 #x77E3 #x4EE5 #x827A #x6291 #x6613 #x9091 #x5C79 #x4EBF #x5F79 #x81C6 #x9038 #x8084 #x75AB #x4EA6 #x88D4 #x610F #x6BC5 #x5FC6 #x4E49 #x76CA #x6EA2 #x8BE3 #x8BAE #x8C0A #x8BD1 #x5F02 #x7FFC #x7FCC #x7ECE #x8335 #x836B #x56E0 #x6BB7 #x97F3 #x9634 #x59FB #x541F #x94F6 #x6DEB #x5BC5 #x996E #x5C39 #x5F15 #x9690 #x5370 #x82F1 #x6A31 #x5A74 #x9E70 #x5E94 #x7F28 #x83B9 #x8424 #x8425 #x8367 #x8747 #x8FCE #x8D62 #x76C8 #x5F71 #x9896 #x786C #x6620 #x54DF #x62E5 #x4F63 #x81C3 #x75C8 #x5EB8 #x96CD #x8E0A #x86F9 #x548F #x6CF3 #x6D8C #x6C38 #x607F #x52C7 #x7528 #x5E7D #x4F18 #x60A0 #x5FE7 #x5C24 #x7531 #x90AE #x94C0 #x72B9 #x6CB9 #x6E38 #x9149 #x6709 #x53CB #x53F3 #x4F51 #x91C9 #x8BF1 #x53C8 #x5E7C #x8FC2 #x6DE4 #x4E8E #x76C2 #x6986 #x865E #x611A #x8206 #x4F59 #x4FDE #x903E #x9C7C #x6109 #x6E1D #x6E14 #x9685 #x4E88 #x5A31 #x96E8 #x4E0E #x5C7F #x79B9 #x5B87 #x8BED #x7FBD #x7389 #x57DF #x828B #x90C1 #x5401 #x9047 #x55BB #x5CEA #x5FA1 #x6108 #x6B32 #x72F1 #x80B2 #x8A89 #x6D74 #x5BD3 #x88D5 #x9884 #x8C6B #x9A6D #x9E33 #x6E0A #x51A4 #x5143 #x57A3 #x8881 #x539F #x63F4 #x8F95 #x56ED #x5458 #x5706 #x733F #x6E90 #x7F18 #x8FDC #x82D1 #x613F #x6028 #x9662 #x66F0 #x7EA6 #x8D8A #x8DC3 #x94A5 #x5CB3 #x7CA4 #x6708 #x60A6 #x9605 #x8018 #x4E91 #x90E7 #x5300 #x9668 #x5141 #x8FD0 #x8574 #x915D #x6655 #x97F5 #x5B55 #x531D #x7838 #x6742 #x683D #x54C9 #x707E #x5BB0 #x8F7D #x518D #x5728 #x54B1 #x6512 #x6682 #x8D5E #x8D43 #x810F #x846C #x906D #x7CDF #x51FF #x85FB #x67A3 #x65E9 #x6FA1 #x86A4 #x8E81 #x566A #x9020 #x7682 #x7076 #x71E5 #x8D23 #x62E9 #x5219 #x6CFD #x8D3C #x600E #x589E #x618E #x66FE #x8D60 #x624E #x55B3 #x6E23 #x672D #x8F67 #x94E1 #x95F8 #x7728 #x6805 #x69A8 #x548B #x4E4D #x70B8 #x8BC8 #x6458 #x658B #x5B85 #x7A84 #x503A #x5BE8 #x77BB #x6BE1 #x8A79 #x7C98 #x6CBE #x76CF #x65A9 #x8F97 #x5D2D #x5C55 #x8638 #x6808 #x5360 #x6218 #x7AD9 #x6E5B #x7EFD #x6A1F #x7AE0 #x5F70 #x6F33 #x5F20 #x638C #x6DA8 #x6756 #x4E08 #x5E10 #x8D26 #x4ED7 #x80C0 #x7634 #x969C #x62DB #x662D #x627E #x6CBC #x8D75 #x7167 #x7F69 #x5146 #x8087 #x53EC #x906E #x6298 #x54F2 #x86F0 #x8F99 #x8005 #x9517 #x8517 #x8FD9 #x6D59 #x73CD #x659F #x771F #x7504 #x7827 #x81FB #x8D1E #x9488 #x4FA6 #x6795 #x75B9 #x8BCA #x9707 #x632F #x9547 #x9635 #x84B8 #x6323 #x7741 #x5F81 #x72F0 #x4E89 #x6014 #x6574 #x62EF #x6B63 #x653F #x5E27 #x75C7 #x90D1 #x8BC1 #x829D #x679D #x652F #x5431 #x8718 #x77E5 #x80A2 #x8102 #x6C41 #x4E4B #x7EC7 #x804C #x76F4 #x690D #x6B96 #x6267 #x503C #x4F84 #x5740 #x6307 #x6B62 #x8DBE #x53EA #x65E8 #x7EB8 #x5FD7 #x631A #x63B7 #x81F3 #x81F4 #x7F6E #x5E1C #x5CD9 #x5236 #x667A #x79E9 #x7A1A #x8D28 #x7099 #x75D4 #x6EDE #x6CBB #x7A92 #x4E2D #x76C5 #x5FE0 #x949F #x8877 #x7EC8 #x79CD #x80BF #x91CD #x4EF2 #x4F17 #x821F #x5468 #x5DDE #x6D32 #x8BCC #x7CA5 #x8F74 #x8098 #x5E1A #x5492 #x76B1 #x5B99 #x663C #x9AA4 #x73E0 #x682A #x86DB #x6731 #x732A #x8BF8 #x8BDB #x9010 #x7AF9 #x70DB #x716E #x62C4 #x77A9 #x5631 #x4E3B #x8457 #x67F1 #x52A9 #x86C0 #x8D2E #x94F8 #x7B51 #x4F4F #x6CE8 #x795D #x9A7B #x6293 #x722A #x62FD #x4E13 #x7816 #x8F6C #x64B0 #x8D5A #x7BC6 #x6869 #x5E84 #x88C5 #x5986 #x649E #x58EE #x72B6 #x690E #x9525 #x8FFD #x8D58 #x5760 #x7F00 #x8C06 #x51C6 #x6349 #x62D9 #x5353 #x684C #x7422 #x8301 #x914C #x5544 #x7740 #x707C #x6D4A #x5179 #x54A8 #x8D44 #x59FF #x6ECB #x6DC4 #x5B5C #x7D2B #x4ED4 #x7C7D #x6ED3 #x5B50 #x81EA #x6E0D #x5B57 #x9B03 #x68D5 #x8E2A #x5B97 #x7EFC #x603B #x7EB5 #x90B9 #x8D70 #x594F #x63CD #x79DF #x8DB3 #x5352 #x65CF #x7956 #x8BC5 #x963B #x7EC4 #x94BB #x7E82 #x5634 #x9189 #x6700 #x7F6A #x5C0A #x9075 #x6628 #x5DE6 #x4F50 #x67DE #x505A #x4F5C #x5750 #x5EA7 #x4E8D #x4E0C #x5140 #x4E10 #x5EFF #x5345 #x4E15 #x4E98 #x4E1E #x9B32 #x5B6C #x5669 #x4E28 #x79BA #x4E3F #x5315 #x4E47 #x592D #x723B #x536E #x6C10 #x56DF #x80E4 #x9997 #x6BD3 #x777E #x9F17 #x4E36 #x4E9F #x9F10 #x4E5C #x4E69 #x4E93 #x8288 #x5B5B #x556C #x560F #x4EC4 #x538D #x539D #x53A3 #x53A5 #x53AE #x9765 #x8D5D #x531A #x53F5 #x5326 #x532E #x533E #x8D5C #x5366 #x5363 #x5202 #x5208 #x520E #x522D #x5233 #x523F #x5240 #x524C #x525E #x5261 #x525C #x84AF #x527D #x5282 #x5281 #x5290 #x5293 #x5182 #x7F54 #x4EBB #x4EC3 #x4EC9 #x4EC2 #x4EE8 #x4EE1 #x4EEB #x4EDE #x4F1B #x4EF3 #x4F22 #x4F64 #x4EF5 #x4F25 #x4F27 #x4F09 #x4F2B #x4F5E #x4F67 #x6538 #x4F5A #x4F5D #x4F5F #x4F57 #x4F32 #x4F3D #x4F76 #x4F74 #x4F91 #x4F89 #x4F83 #x4F8F #x4F7E #x4F7B #x4FAA #x4F7C #x4FAC #x4F94 #x4FE6 #x4FE8 #x4FEA #x4FC5 #x4FDA #x4FE3 #x4FDC #x4FD1 #x4FDF #x4FF8 #x5029 #x504C #x4FF3 #x502C #x500F #x502E #x502D #x4FFE #x501C #x500C #x5025 #x5028 #x507E #x5043 #x5055 #x5048 #x504E #x506C #x507B #x50A5 #x50A7 #x50A9 #x50BA #x50D6 #x5106 #x50ED #x50EC #x50E6 #x50EE #x5107 #x510B #x4EDD #x6C3D #x4F58 #x4F65 #x4FCE #x9FA0 #x6C46 #x7C74 #x516E #x5DFD #x9EC9 #x9998 #x5181 #x5914 #x52F9 #x530D #x8A07 #x5310 #x51EB #x5919 #x5155 #x4EA0 #x5156 #x4EB3 #x886E #x88A4 #x4EB5 #x8114 #x88D2 #x7980 #x5B34 #x8803 #x7FB8 #x51AB #x51B1 #x51BD #x51BC #x51C7 #x5196 #x51A2 #x51A5 #x8BA0 #x8BA6 #x8BA7 #x8BAA #x8BB4 #x8BB5 #x8BB7 #x8BC2 #x8BC3 #x8BCB #x8BCF #x8BCE #x8BD2 #x8BD3 #x8BD4 #x8BD6 #x8BD8 #x8BD9 #x8BDC #x8BDF #x8BE0 #x8BE4 #x8BE8 #x8BE9 #x8BEE #x8BF0 #x8BF3 #x8BF6 #x8BF9 #x8BFC #x8BFF #x8C00 #x8C02 #x8C04 #x8C07 #x8C0C #x8C0F #x8C11 #x8C12 #x8C14 #x8C15 #x8C16 #x8C19 #x8C1B #x8C18 #x8C1D #x8C1F #x8C20 #x8C21 #x8C25 #x8C27 #x8C2A #x8C2B #x8C2E #x8C2F #x8C32 #x8C33 #x8C35 #x8C36 #x5369 #x537A #x961D #x9622 #x9621 #x9631 #x962A #x963D #x963C #x9642 #x9649 #x9654 #x965F #x9667 #x966C #x9672 #x9674 #x9688 #x968D #x9697 #x96B0 #x9097 #x909B #x909D #x9099 #x90AC #x90A1 #x90B4 #x90B3 #x90B6 #x90BA #x90B8 #x90B0 #x90CF #x90C5 #x90BE #x90D0 #x90C4 #x90C7 #x90D3 #x90E6 #x90E2 #x90DC #x90D7 #x90DB #x90EB #x90EF #x90FE #x9104 #x9122 #x911E #x9123 #x9131 #x912F #x9139 #x9143 #x9146 #x520D #x5942 #x52A2 #x52AC #x52AD #x52BE #x54FF #x52D0 #x52D6 #x52F0 #x53DF #x71EE #x77CD #x5EF4 #x51F5 #x51FC #x9B2F #x53B6 #x5F01 #x755A #x5DEF #x574C #x57A9 #x57A1 #x587E #x58BC #x58C5 #x58D1 #x5729 #x572C #x572A #x5733 #x5739 #x572E #x572F #x575C #x573B #x5742 #x5769 #x5785 #x576B #x5786 #x577C #x577B #x5768 #x576D #x5776 #x5773 #x57AD #x57A4 #x578C #x57B2 #x57CF #x57A7 #x57B4 #x5793 #x57A0 #x57D5 #x57D8 #x57DA #x57D9 #x57D2 #x57B8 #x57F4 #x57EF #x57F8 #x57E4 #x57DD #x580B #x580D #x57FD #x57ED #x5800 #x581E #x5819 #x5844 #x5820 #x5865 #x586C #x5881 #x5889 #x589A #x5880 #x99A8 #x9F19 #x61FF #x8279 #x827D #x827F #x828F #x828A #x82A8 #x8284 #x828E #x8291 #x8297 #x8299 #x82AB #x82B8 #x82BE #x82B0 #x82C8 #x82CA #x82E3 #x8298 #x82B7 #x82AE #x82CB #x82CC #x82C1 #x82A9 #x82B4 #x82A1 #x82AA #x829F #x82C4 #x82CE #x82A4 #x82E1 #x8309 #x82F7 #x82E4 #x830F #x8307 #x82DC #x82F4 #x82D2 #x82D8 #x830C #x82FB #x82D3 #x8311 #x831A #x8306 #x8314 #x8315 #x82E0 #x82D5 #x831C #x8351 #x835B #x835C #x8308 #x8392 #x833C #x8334 #x8331 #x839B #x835E #x832F #x834F #x8347 #x8343 #x835F #x8340 #x8317 #x8360 #x832D #x833A #x8333 #x8366 #x8365 #x8368 #x831B #x8369 #x836C #x836A #x836D #x836E #x83B0 #x8378 #x83B3 #x83B4 #x83A0 #x83AA #x8393 #x839C #x8385 #x837C #x83B6 #x83A9 #x837D #x83B8 #x837B #x8398 #x839E #x83A8 #x83BA #x83BC #x83C1 #x8401 #x83E5 #x83D8 #x5807 #x8418 #x840B #x83DD #x83FD #x83D6 #x841C #x8438 #x8411 #x8406 #x83D4 #x83DF #x840F #x8403 #x83F8 #x83F9 #x83EA #x83C5 #x83C0 #x8426 #x83F0 #x83E1 #x845C #x8451 #x845A #x8459 #x8473 #x8487 #x8488 #x847A #x8489 #x8478 #x843C #x8446 #x8469 #x8476 #x848C #x848E #x8431 #x846D #x84C1 #x84CD #x84D0 #x84E6 #x84BD #x84D3 #x84CA #x84BF #x84BA #x84E0 #x84A1 #x84B9 #x84B4 #x8497 #x84E5 #x84E3 #x850C #x750D #x8538 #x84F0 #x8539 #x851F #x853A #x8556 #x853B #x84FF #x84FC #x8559 #x8548 #x8568 #x8564 #x855E #x857A #x77A2 #x8543 #x8572 #x857B #x85A4 #x85A8 #x8587 #x858F #x8579 #x85AE #x859C #x8585 #x85B9 #x85B7 #x85B0 #x85D3 #x85C1 #x85DC #x85FF #x8627 #x8605 #x8629 #x8616 #x863C #x5EFE #x5F08 #x593C #x5941 #x8037 #x5955 #x595A #x5958 #x530F #x5C22 #x5C25 #x5C2C #x5C34 #x624C #x626A #x629F #x62BB #x62CA #x62DA #x62D7 #x62EE #x6322 #x62F6 #x6339 #x634B #x6343 #x63AD #x63F6 #x6371 #x637A #x638E #x63B4 #x636D #x63AC #x638A #x6369 #x63AE #x63BC #x63F2 #x63F8 #x63E0 #x63FF #x63C4 #x63DE #x63CE #x6452 #x63C6 #x63BE #x6445 #x6441 #x640B #x641B #x6420 #x640C #x6426 #x6421 #x645E #x6484 #x646D #x6496 #x647A #x64B7 #x64B8 #x6499 #x64BA #x64C0 #x64D0 #x64D7 #x64E4 #x64E2 #x6509 #x6525 #x652E #x5F0B #x5FD2 #x7519 #x5F11 #x535F #x53F1 #x53FD #x53E9 #x53E8 #x53FB #x5412 #x5416 #x5406 #x544B #x5452 #x5453 #x5454 #x5456 #x5443 #x5421 #x5457 #x5459 #x5423 #x5432 #x5482 #x5494 #x5477 #x5471 #x5464 #x549A #x549B #x5484 #x5476 #x5466 #x549D #x54D0 #x54AD #x54C2 #x54B4 #x54D2 #x54A7 #x54A6 #x54D3 #x54D4 #x5472 #x54A3 #x54D5 #x54BB #x54BF #x54CC #x54D9 #x54DA #x54DC #x54A9 #x54AA #x54A4 #x54DD #x54CF #x54DE #x551B #x54E7 #x5520 #x54FD #x5514 #x54F3 #x5522 #x5523 #x550F #x5511 #x5527 #x552A #x5567 #x558F #x55B5 #x5549 #x556D #x5541 #x5555 #x553F #x5550 #x553C #x5537 #x5556 #x5575 #x5576 #x5577 #x5533 #x5530 #x555C #x558B #x55D2 #x5583 #x55B1 #x55B9 #x5588 #x5581 #x559F #x557E #x55D6 #x5591 #x557B #x55DF #x55BD #x55BE #x5594 #x5599 #x55EA #x55F7 #x55C9 #x561F #x55D1 #x55EB #x55EC #x55D4 #x55E6 #x55DD #x55C4 #x55EF #x55E5 #x55F2 #x55F3 #x55CC #x55CD #x55E8 #x55F5 #x55E4 #x8F94 #x561E #x5608 #x560C #x5601 #x5624 #x5623 #x55FE #x5600 #x5627 #x562D #x5658 #x5639 #x5657 #x562C #x564D #x5662 #x5659 #x565C #x564C #x5654 #x5686 #x5664 #x5671 #x566B #x567B #x567C #x5685 #x5693 #x56AF #x56D4 #x56D7 #x56DD #x56E1 #x56F5 #x56EB #x56F9 #x56FF #x5704 #x570A #x5709 #x571C #x5E0F #x5E19 #x5E14 #x5E11 #x5E31 #x5E3B #x5E3C #x5E37 #x5E44 #x5E54 #x5E5B #x5E5E #x5E61 #x5C8C #x5C7A #x5C8D #x5C90 #x5C96 #x5C88 #x5C98 #x5C99 #x5C91 #x5C9A #x5C9C #x5CB5 #x5CA2 #x5CBD #x5CAC #x5CAB #x5CB1 #x5CA3 #x5CC1 #x5CB7 #x5CC4 #x5CD2 #x5CE4 #x5CCB #x5CE5 #x5D02 #x5D03 #x5D27 #x5D26 #x5D2E #x5D24 #x5D1E #x5D06 #x5D1B #x5D58 #x5D3E #x5D34 #x5D3D #x5D6C #x5D5B #x5D6F #x5D5D #x5D6B #x5D4B #x5D4A #x5D69 #x5D74 #x5D82 #x5D99 #x5D9D #x8C73 #x5DB7 #x5DC5 #x5F73 #x5F77 #x5F82 #x5F87 #x5F89 #x5F8C #x5F95 #x5F99 #x5F9C #x5FA8 #x5FAD #x5FB5 #x5FBC #x8862 #x5F61 #x72AD #x72B0 #x72B4 #x72B7 #x72B8 #x72C3 #x72C1 #x72CE #x72CD #x72D2 #x72E8 #x72EF #x72E9 #x72F2 #x72F4 #x72F7 #x7301 #x72F3 #x7303 #x72FA #x72FB #x7317 #x7313 #x7321 #x730A #x731E #x731D #x7315 #x7322 #x7339 #x7325 #x732C #x7338 #x7331 #x7350 #x734D #x7357 #x7360 #x736C #x736F #x737E #x821B #x5925 #x98E7 #x5924 #x5902 #x9963 #x9967 #x9968 #x9969 #x996A #x996B #x996C #x9974 #x9977 #x997D #x9980 #x9984 #x9987 #x998A #x998D #x9990 #x9991 #x9993 #x9994 #x9995 #x5E80 #x5E91 #x5E8B #x5E96 #x5EA5 #x5EA0 #x5EB9 #x5EB5 #x5EBE #x5EB3 #x8D53 #x5ED2 #x5ED1 #x5EDB #x5EE8 #x5EEA #x81BA #x5FC4 #x5FC9 #x5FD6 #x5FCF #x6003 #x5FEE #x6004 #x5FE1 #x5FE4 #x5FFE #x6005 #x6006 #x5FEA #x5FED #x5FF8 #x6019 #x6035 #x6026 #x601B #x600F #x600D #x6029 #x602B #x600A #x603F #x6021 #x6078 #x6079 #x607B #x607A #x6042 #x606A #x607D #x6096 #x609A #x60AD #x609D #x6083 #x6092 #x608C #x609B #x60EC #x60BB #x60B1 #x60DD #x60D8 #x60C6 #x60DA #x60B4 #x6120 #x6126 #x6115 #x6123 #x60F4 #x6100 #x610E #x612B #x614A #x6175 #x61AC #x6194 #x61A7 #x61B7 #x61D4 #x61F5 #x5FDD #x96B3 #x95E9 #x95EB #x95F1 #x95F3 #x95F5 #x95F6 #x95FC #x95FE #x9603 #x9604 #x9606 #x9608 #x960A #x960B #x960C #x960D #x960F #x9612 #x9615 #x9616 #x9617 #x9619 #x961A #x4E2C #x723F #x6215 #x6C35 #x6C54 #x6C5C #x6C4A #x6CA3 #x6C85 #x6C90 #x6C94 #x6C8C #x6C68 #x6C69 #x6C74 #x6C76 #x6C86 #x6CA9 #x6CD0 #x6CD4 #x6CAD #x6CF7 #x6CF8 #x6CF1 #x6CD7 #x6CB2 #x6CE0 #x6CD6 #x6CFA #x6CEB #x6CEE #x6CB1 #x6CD3 #x6CEF #x6CFE #x6D39 #x6D27 #x6D0C #x6D43 #x6D48 #x6D07 #x6D04 #x6D19 #x6D0E #x6D2B #x6D4D #x6D2E #x6D35 #x6D1A #x6D4F #x6D52 #x6D54 #x6D33 #x6D91 #x6D6F #x6D9E #x6DA0 #x6D5E #x6D93 #x6D94 #x6D5C #x6D60 #x6D7C #x6D63 #x6E1A #x6DC7 #x6DC5 #x6DDE #x6E0E #x6DBF #x6DE0 #x6E11 #x6DE6 #x6DDD #x6DD9 #x6E16 #x6DAB #x6E0C #x6DAE #x6E2B #x6E6E #x6E4E #x6E6B #x6EB2 #x6E5F #x6E86 #x6E53 #x6E54 #x6E32 #x6E25 #x6E44 #x6EDF #x6EB1 #x6E98 #x6EE0 #x6F2D #x6EE2 #x6EA5 #x6EA7 #x6EBD #x6EBB #x6EB7 #x6ED7 #x6EB4 #x6ECF #x6E8F #x6EC2 #x6E9F #x6F62 #x6F46 #x6F47 #x6F24 #x6F15 #x6EF9 #x6F2F #x6F36 #x6F4B #x6F74 #x6F2A #x6F09 #x6F29 #x6F89 #x6F8D #x6F8C #x6F78 #x6F72 #x6F7C #x6F7A #x6FD1 #x6FC9 #x6FA7 #x6FB9 #x6FB6 #x6FC2 #x6FE1 #x6FEE #x6FDE #x6FE0 #x6FEF #x701A #x7023 #x701B #x7039 #x7035 #x704F #x705E #x5B80 #x5B84 #x5B95 #x5B93 #x5BA5 #x5BB8 #x752F #x9A9E #x6434 #x5BE4 #x5BEE #x8930 #x5BF0 #x8E47 #x8B07 #x8FB6 #x8FD3 #x8FD5 #x8FE5 #x8FEE #x8FE4 #x8FE9 #x8FE6 #x8FF3 #x8FE8 #x9005 #x9004 #x900B #x9026 #x9011 #x900D #x9016 #x9021 #x9035 #x9036 #x902D #x902F #x9044 #x9051 #x9052 #x9050 #x9068 #x9058 #x9062 #x905B #x66B9 #x9074 #x907D #x9082 #x9088 #x9083 #x908B #x5F50 #x5F57 #x5F56 #x5F58 #x5C3B #x54AB #x5C50 #x5C59 #x5B71 #x5C63 #x5C66 #x7FBC #x5F2A #x5F29 #x5F2D #x8274 #x5F3C #x9B3B #x5C6E #x5981 #x5983 #x598D #x59A9 #x59AA #x59A3 #x5997 #x59CA #x59AB #x599E #x59A4 #x59D2 #x59B2 #x59AF #x59D7 #x59BE #x5A05 #x5A06 #x59DD #x5A08 #x59E3 #x59D8 #x59F9 #x5A0C #x5A09 #x5A32 #x5A34 #x5A11 #x5A23 #x5A13 #x5A40 #x5A67 #x5A4A #x5A55 #x5A3C #x5A62 #x5A75 #x80EC #x5AAA #x5A9B #x5A77 #x5A7A #x5ABE #x5AEB #x5AB2 #x5AD2 #x5AD4 #x5AB8 #x5AE0 #x5AE3 #x5AF1 #x5AD6 #x5AE6 #x5AD8 #x5ADC #x5B09 #x5B17 #x5B16 #x5B32 #x5B37 #x5B40 #x5C15 #x5C1C #x5B5A #x5B65 #x5B73 #x5B51 #x5B53 #x5B62 #x9A75 #x9A77 #x9A78 #x9A7A #x9A7F #x9A7D #x9A80 #x9A81 #x9A85 #x9A88 #x9A8A #x9A90 #x9A92 #x9A93 #x9A96 #x9A98 #x9A9B #x9A9C #x9A9D #x9A9F #x9AA0 #x9AA2 #x9AA3 #x9AA5 #x9AA7 #x7E9F #x7EA1 #x7EA3 #x7EA5 #x7EA8 #x7EA9 #x7EAD #x7EB0 #x7EBE #x7EC0 #x7EC1 #x7EC2 #x7EC9 #x7ECB #x7ECC #x7ED0 #x7ED4 #x7ED7 #x7EDB #x7EE0 #x7EE1 #x7EE8 #x7EEB #x7EEE #x7EEF #x7EF1 #x7EF2 #x7F0D #x7EF6 #x7EFA #x7EFB #x7EFE #x7F01 #x7F02 #x7F03 #x7F07 #x7F08 #x7F0B #x7F0C #x7F0F #x7F11 #x7F12 #x7F17 #x7F19 #x7F1C #x7F1B #x7F1F #x7F21 #x7F22 #x7F23 #x7F24 #x7F25 #x7F26 #x7F27 #x7F2A #x7F2B #x7F2C #x7F2D #x7F2F #x7F30 #x7F31 #x7F32 #x7F33 #x7F35 #x5E7A #x757F #x5DDB #x753E #x9095 #x738E #x7391 #x73AE #x73A2 #x739F #x73CF #x73C2 #x73D1 #x73B7 #x73B3 #x73C0 #x73C9 #x73C8 #x73E5 #x73D9 #x987C #x740A #x73E9 #x73E7 #x73DE #x73BA #x73F2 #x740F #x742A #x745B #x7426 #x7425 #x7428 #x7430 #x742E #x742C #x741B #x741A #x7441 #x745C #x7457 #x7455 #x7459 #x7477 #x746D #x747E #x749C #x748E #x7480 #x7481 #x7487 #x748B #x749E #x74A8 #x74A9 #x7490 #x74A7 #x74D2 #x74BA #x97EA #x97EB #x97EC #x674C #x6753 #x675E #x6748 #x6769 #x67A5 #x6787 #x676A #x6773 #x6798 #x67A7 #x6775 #x67A8 #x679E #x67AD #x678B #x6777 #x677C #x67F0 #x6809 #x67D8 #x680A #x67E9 #x67B0 #x680C #x67D9 #x67B5 #x67DA #x67B3 #x67DD #x6800 #x67C3 #x67B8 #x67E2 #x680E #x67C1 #x67FD #x6832 #x6833 #x6860 #x6861 #x684E #x6862 #x6844 #x6864 #x6883 #x681D #x6855 #x6866 #x6841 #x6867 #x6840 #x683E #x684A #x6849 #x6829 #x68B5 #x688F #x6874 #x6877 #x6893 #x686B #x68C2 #x696E #x68FC #x691F #x6920 #x68F9 #x6924 #x68F0 #x690B #x6901 #x6957 #x68E3 #x6910 #x6971 #x6939 #x6960 #x6942 #x695D #x6984 #x696B #x6980 #x6998 #x6978 #x6934 #x69CC #x6987 #x6988 #x69CE #x6989 #x6966 #x6963 #x6979 #x699B #x69A7 #x69BB #x69AB #x69AD #x69D4 #x69B1 #x69C1 #x69CA #x69DF #x6995 #x69E0 #x698D #x69FF #x6A2F #x69ED #x6A17 #x6A18 #x6A65 #x69F2 #x6A44 #x6A3E #x6AA0 #x6A50 #x6A5B #x6A35 #x6A8E #x6A79 #x6A3D #x6A28 #x6A58 #x6A7C #x6A91 #x6A90 #x6AA9 #x6A97 #x6AAB #x7337 #x7352 #x6B81 #x6B82 #x6B87 #x6B84 #x6B92 #x6B93 #x6B8D #x6B9A #x6B9B #x6BA1 #x6BAA #x8F6B #x8F6D #x8F71 #x8F72 #x8F73 #x8F75 #x8F76 #x8F78 #x8F77 #x8F79 #x8F7A #x8F7C #x8F7E #x8F81 #x8F82 #x8F84 #x8F87 #x8F8B #x8F8D #x8F8E #x8F8F #x8F98 #x8F9A #x8ECE #x620B #x6217 #x621B #x621F #x6222 #x6221 #x6225 #x6224 #x622C #x81E7 #x74EF #x74F4 #x74FF #x750F #x7511 #x7513 #x6534 #x65EE #x65EF #x65F0 #x660A #x6619 #x6772 #x6603 #x6615 #x6600 #x7085 #x66F7 #x661D #x6634 #x6631 #x6636 #x6635 #x8006 #x665F #x6654 #x6641 #x664F #x6656 #x6661 #x6657 #x6677 #x6684 #x668C #x66A7 #x669D #x66BE #x66DB #x66DC #x66E6 #x66E9 #x8D32 #x8D33 #x8D36 #x8D3B #x8D3D #x8D40 #x8D45 #x8D46 #x8D48 #x8D49 #x8D47 #x8D4D #x8D55 #x8D59 #x89C7 #x89CA #x89CB #x89CC #x89CE #x89CF #x89D0 #x89D1 #x726E #x729F #x725D #x7266 #x726F #x727E #x727F #x7284 #x728B #x728D #x728F #x7292 #x6308 #x6332 #x63B0 #x643F #x64D8 #x8004 #x6BEA #x6BF3 #x6BFD #x6BF5 #x6BF9 #x6C05 #x6C07 #x6C06 #x6C0D #x6C15 #x6C18 #x6C19 #x6C1A #x6C21 #x6C29 #x6C24 #x6C2A #x6C32 #x6535 #x6555 #x656B #x724D #x7252 #x7256 #x7230 #x8662 #x5216 #x809F #x809C #x8093 #x80BC #x670A #x80BD #x80B1 #x80AB #x80AD #x80B4 #x80B7 #x80E7 #x80E8 #x80E9 #x80EA #x80DB #x80C2 #x80C4 #x80D9 #x80CD #x80D7 #x6710 #x80DD #x80EB #x80F1 #x80F4 #x80ED #x810D #x810E #x80F2 #x80FC #x6715 #x8112 #x8C5A #x8136 #x811E #x812C #x8118 #x8132 #x8148 #x814C #x8153 #x8174 #x8159 #x815A #x8171 #x8160 #x8169 #x817C #x817D #x816D #x8167 #x584D #x5AB5 #x8188 #x8182 #x8191 #x6ED5 #x81A3 #x81AA #x81CC #x6726 #x81CA #x81BB #x81C1 #x81A6 #x6B24 #x6B37 #x6B39 #x6B43 #x6B46 #x6B59 #x98D1 #x98D2 #x98D3 #x98D5 #x98D9 #x98DA #x6BB3 #x5F40 #x6BC2 #x89F3 #x6590 #x9F51 #x6593 #x65BC #x65C6 #x65C4 #x65C3 #x65CC #x65CE #x65D2 #x65D6 #x7080 #x709C #x7096 #x709D #x70BB #x70C0 #x70B7 #x70AB #x70B1 #x70E8 #x70CA #x7110 #x7113 #x7116 #x712F #x7131 #x7173 #x715C #x7168 #x7145 #x7172 #x714A #x7178 #x717A #x7198 #x71B3 #x71B5 #x71A8 #x71A0 #x71E0 #x71D4 #x71E7 #x71F9 #x721D #x7228 #x706C #x7118 #x7166 #x71B9 #x623E #x623D #x6243 #x6248 #x6249 #x793B #x7940 #x7946 #x7949 #x795B #x795C #x7953 #x795A #x7962 #x7957 #x7960 #x796F #x7967 #x797A #x7985 #x798A #x799A #x79A7 #x79B3 #x5FD1 #x5FD0 #x603C #x605D #x605A #x6067 #x6041 #x6059 #x6063 #x60AB #x6106 #x610D #x615D #x61A9 #x619D #x61CB #x61D1 #x6206 #x8080 #x807F #x6C93 #x6CF6 #x6DFC #x77F6 #x77F8 #x7800 #x7809 #x7817 #x7818 #x7811 #x65AB #x782D #x781C #x781D #x7839 #x783A #x783B #x781F #x783C #x7825 #x782C #x7823 #x7829 #x784E #x786D #x7856 #x7857 #x7826 #x7850 #x7847 #x784C #x786A #x789B #x7893 #x789A #x7887 #x789C #x78A1 #x78A3 #x78B2 #x78B9 #x78A5 #x78D4 #x78D9 #x78C9 #x78EC #x78F2 #x7905 #x78F4 #x7913 #x7924 #x791E #x7934 #x9F9B #x9EF9 #x9EFB #x9EFC #x76F1 #x7704 #x770D #x76F9 #x7707 #x7708 #x771A #x7722 #x7719 #x772D #x7726 #x7735 #x7738 #x7750 #x7751 #x7747 #x7743 #x775A #x7768 #x7762 #x7765 #x777F #x778D #x777D #x7780 #x778C #x7791 #x779F #x77A0 #x77B0 #x77B5 #x77BD #x753A #x7540 #x754E #x754B #x7548 #x755B #x7572 #x7579 #x7583 #x7F58 #x7F61 #x7F5F #x8A48 #x7F68 #x7F74 #x7F71 #x7F79 #x7F81 #x7F7E #x76CD #x76E5 #x8832 #x9485 #x9486 #x9487 #x948B #x948A #x948C #x948D #x948F #x9490 #x9494 #x9497 #x9495 #x949A #x949B #x949C #x94A3 #x94A4 #x94AB #x94AA #x94AD #x94AC #x94AF #x94B0 #x94B2 #x94B4 #x94B6 #x94B7 #x94B8 #x94B9 #x94BA #x94BC #x94BD #x94BF #x94C4 #x94C8 #x94C9 #x94CA #x94CB #x94CC #x94CD #x94CE #x94D0 #x94D1 #x94D2 #x94D5 #x94D6 #x94D7 #x94D9 #x94D8 #x94DB #x94DE #x94DF #x94E0 #x94E2 #x94E4 #x94E5 #x94E7 #x94E8 #x94EA #x94E9 #x94EB #x94EE #x94EF #x94F3 #x94F4 #x94F5 #x94F7 #x94F9 #x94FC #x94FD #x94FF #x9503 #x9502 #x9506 #x9507 #x9509 #x950A #x950D #x950E #x950F #x9512 #x9513 #x9514 #x9515 #x9516 #x9518 #x951B #x951D #x951E #x951F #x9522 #x952A #x952B #x9529 #x952C #x9531 #x9532 #x9534 #x9536 #x9537 #x9538 #x953C #x953E #x953F #x9542 #x9535 #x9544 #x9545 #x9546 #x9549 #x954C #x954E #x954F #x9552 #x9553 #x9554 #x9556 #x9557 #x9558 #x9559 #x955B #x955E #x955F #x955D #x9561 #x9562 #x9564 #x9565 #x9566 #x9567 #x9568 #x9569 #x956A #x956B #x956C #x956F #x9571 #x9572 #x9573 #x953A #x77E7 #x77EC #x96C9 #x79D5 #x79ED #x79E3 #x79EB #x7A06 #x5D47 #x7A03 #x7A02 #x7A1E #x7A14 #x7A39 #x7A37 #x7A51 #x9ECF #x99A5 #x7A70 #x7688 #x768E #x7693 #x7699 #x76A4 #x74DE #x74E0 #x752C #x9E20 #x9E22 #x9E28 #x9E29 #x9E2A #x9E2B #x9E2C #x9E32 #x9E31 #x9E36 #x9E38 #x9E37 #x9E39 #x9E3A #x9E3E #x9E41 #x9E42 #x9E44 #x9E46 #x9E47 #x9E48 #x9E49 #x9E4B #x9E4C #x9E4E #x9E51 #x9E55 #x9E57 #x9E5A #x9E5B #x9E5C #x9E5E #x9E63 #x9E66 #x9E67 #x9E68 #x9E69 #x9E6A #x9E6B #x9E6C #x9E71 #x9E6D #x9E73 #x7592 #x7594 #x7596 #x75A0 #x759D #x75AC #x75A3 #x75B3 #x75B4 #x75B8 #x75C4 #x75B1 #x75B0 #x75C3 #x75C2 #x75D6 #x75CD #x75E3 #x75E8 #x75E6 #x75E4 #x75EB #x75E7 #x7603 #x75F1 #x75FC #x75FF #x7610 #x7600 #x7605 #x760C #x7617 #x760A #x7625 #x7618 #x7615 #x7619 #x761B #x763C #x7622 #x7620 #x7640 #x762D #x7630 #x763F #x7635 #x7643 #x763E #x7633 #x764D #x765E #x7654 #x765C #x7656 #x766B #x766F #x7FCA #x7AE6 #x7A78 #x7A79 #x7A80 #x7A86 #x7A88 #x7A95 #x7AA6 #x7AA0 #x7AAC #x7AA8 #x7AAD #x7AB3 #x8864 #x8869 #x8872 #x887D #x887F #x8882 #x88A2 #x88C6 #x88B7 #x88BC #x88C9 #x88E2 #x88CE #x88E3 #x88E5 #x88F1 #x891A #x88FC #x88E8 #x88FE #x88F0 #x8921 #x8919 #x8913 #x891B #x890A #x8934 #x892B #x8936 #x8941 #x8966 #x897B #x758B #x80E5 #x76B2 #x76B4 #x77DC #x8012 #x8014 #x8016 #x801C #x8020 #x8022 #x8025 #x8026 #x8027 #x8029 #x8028 #x8031 #x800B #x8035 #x8043 #x8046 #x804D #x8052 #x8069 #x8071 #x8983 #x9878 #x9880 #x9883 #x9889 #x988C #x988D #x988F #x9894 #x989A #x989B #x989E #x989F #x98A1 #x98A2 #x98A5 #x98A6 #x864D #x8654 #x866C #x866E #x867F #x867A #x867C #x867B #x86A8 #x868D #x868B #x86AC #x869D #x86A7 #x86A3 #x86AA #x8693 #x86A9 #x86B6 #x86C4 #x86B5 #x86CE #x86B0 #x86BA #x86B1 #x86AF #x86C9 #x86CF #x86B4 #x86E9 #x86F1 #x86F2 #x86ED #x86F3 #x86D0 #x8713 #x86DE #x86F4 #x86DF #x86D8 #x86D1 #x8703 #x8707 #x86F8 #x8708 #x870A #x870D #x8709 #x8723 #x873B #x871E #x8725 #x872E #x871A #x873E #x8748 #x8734 #x8731 #x8729 #x8737 #x873F #x8782 #x8722 #x877D #x877E #x877B #x8760 #x8770 #x874C #x876E #x878B #x8753 #x8763 #x877C #x8764 #x8759 #x8765 #x8793 #x87AF #x87A8 #x87D2 #x87C6 #x8788 #x8785 #x87AD #x8797 #x8783 #x87AB #x87E5 #x87AC #x87B5 #x87B3 #x87CB #x87D3 #x87BD #x87D1 #x87C0 #x87CA #x87DB #x87EA #x87E0 #x87EE #x8816 #x8813 #x87FE #x880A #x881B #x8821 #x8839 #x883C #x7F36 #x7F42 #x7F44 #x7F45 #x8210 #x7AFA #x7AFD #x7B08 #x7B03 #x7B04 #x7B15 #x7B0A #x7B2B #x7B0F #x7B47 #x7B38 #x7B2A #x7B19 #x7B2E #x7B31 #x7B20 #x7B25 #x7B24 #x7B33 #x7B3E #x7B1E #x7B58 #x7B5A #x7B45 #x7B75 #x7B4C #x7B5D #x7B60 #x7B6E #x7B7B #x7B62 #x7B72 #x7B71 #x7B90 #x7BA6 #x7BA7 #x7BB8 #x7BAC #x7B9D #x7BA8 #x7B85 #x7BAA #x7B9C #x7BA2 #x7BAB #x7BB4 #x7BD1 #x7BC1 #x7BCC #x7BDD #x7BDA #x7BE5 #x7BE6 #x7BEA #x7C0C #x7BFE #x7BFC #x7C0F #x7C16 #x7C0B #x7C1F #x7C2A #x7C26 #x7C38 #x7C41 #x7C40 #x81FE #x8201 #x8202 #x8204 #x81EC #x8844 #x8221 #x8222 #x8223 #x822D #x822F #x8228 #x822B #x8238 #x823B #x8233 #x8234 #x823E #x8244 #x8249 #x824B #x824F #x825A #x825F #x8268 #x887E #x8885 #x8888 #x88D8 #x88DF #x895E #x7F9D #x7F9F #x7FA7 #x7FAF #x7FB0 #x7FB2 #x7C7C #x6549 #x7C91 #x7C9D #x7C9C #x7C9E #x7CA2 #x7CB2 #x7CBC #x7CBD #x7CC1 #x7CC7 #x7CCC #x7CCD #x7CC8 #x7CC5 #x7CD7 #x7CE8 #x826E #x66A8 #x7FBF #x7FCE #x7FD5 #x7FE5 #x7FE1 #x7FE6 #x7FE9 #x7FEE #x7FF3 #x7CF8 #x7D77 #x7DA6 #x7DAE #x7E47 #x7E9B #x9EB8 #x9EB4 #x8D73 #x8D84 #x8D94 #x8D91 #x8DB1 #x8D67 #x8D6D #x8C47 #x8C49 #x914A #x9150 #x914E #x914F #x9164 #x9162 #x9161 #x9170 #x9169 #x916F #x917D #x917E #x9172 #x9174 #x9179 #x918C #x9185 #x9190 #x918D #x9191 #x91A2 #x91A3 #x91AA #x91AD #x91AE #x91AF #x91B5 #x91B4 #x91BA #x8C55 #x9E7E #x8DB8 #x8DEB #x8E05 #x8E59 #x8E69 #x8DB5 #x8DBF #x8DBC #x8DBA #x8DC4 #x8DD6 #x8DD7 #x8DDA #x8DDE #x8DCE #x8DCF #x8DDB #x8DC6 #x8DEC #x8DF7 #x8DF8 #x8DE3 #x8DF9 #x8DFB #x8DE4 #x8E09 #x8DFD #x8E14 #x8E1D #x8E1F #x8E2C #x8E2E #x8E23 #x8E2F #x8E3A #x8E40 #x8E39 #x8E35 #x8E3D #x8E31 #x8E49 #x8E41 #x8E42 #x8E51 #x8E52 #x8E4A #x8E70 #x8E76 #x8E7C #x8E6F #x8E74 #x8E85 #x8E8F #x8E94 #x8E90 #x8E9C #x8E9E #x8C78 #x8C82 #x8C8A #x8C85 #x8C98 #x8C94 #x659B #x89D6 #x89DE #x89DA #x89DC #x89E5 #x89EB #x89EF #x8A3E #x8B26 #x9753 #x96E9 #x96F3 #x96EF #x9706 #x9701 #x9708 #x970F #x970E #x972A #x972D #x9730 #x973E #x9F80 #x9F83 #x9F85 #x9F86 #x9F87 #x9F88 #x9F89 #x9F8A #x9F8C #x9EFE #x9F0B #x9F0D #x96B9 #x96BC #x96BD #x96CE #x96D2 #x77BF #x96E0 #x928E #x92AE #x92C8 #x933E #x936A #x93CA #x938F #x943E #x946B #x9C7F #x9C82 #x9C85 #x9C86 #x9C87 #x9C88 #x7A23 #x9C8B #x9C8E #x9C90 #x9C91 #x9C92 #x9C94 #x9C95 #x9C9A #x9C9B #x9C9E #x9C9F #x9CA0 #x9CA1 #x9CA2 #x9CA3 #x9CA5 #x9CA6 #x9CA7 #x9CA8 #x9CA9 #x9CAB #x9CAD #x9CAE #x9CB0 #x9CB1 #x9CB2 #x9CB3 #x9CB4 #x9CB5 #x9CB6 #x9CB7 #x9CBA #x9CBB #x9CBC #x9CBD #x9CC4 #x9CC5 #x9CC6 #x9CC7 #x9CCA #x9CCB #x9CCC #x9CCD #x9CCE #x9CCF #x9CD0 #x9CD3 #x9CD4 #x9CD5 #x9CD7 #x9CD8 #x9CD9 #x9CDC #x9CDD #x9CDF #x9CE2 #x977C #x9785 #x9791 #x9792 #x9794 #x97AF #x97AB #x97A3 #x97B2 #x97B4 #x9AB1 #x9AB0 #x9AB7 #x9E58 #x9AB6 #x9ABA #x9ABC #x9AC1 #x9AC0 #x9AC5 #x9AC2 #x9ACB #x9ACC #x9AD1 #x9B45 #x9B43 #x9B47 #x9B49 #x9B48 #x9B4D #x9B51 #x98E8 #x990D #x992E #x9955 #x9954 #x9ADF #x9AE1 #x9AE6 #x9AEF #x9AEB #x9AFB #x9AED #x9AF9 #x9B08 #x9B0F #x9B13 #x9B1F #x9B23 #x9EBD #x9EBE #x7E3B #x9E82 #x9E87 #x9E88 #x9E8B #x9E92 #x93D6 #x9E9D #x9E9F #x9EDB #x9EDC #x9EDD #x9EE0 #x9EDF #x9EE2 #x9EE9 #x9EE7 #x9EE5 #x9EEA #x9EEF #x9F22 #x9F2C #x9F2F #x9F39 #x9F37 #x9F3D #x9F3E #x9F44 #x4E02 #x4E04 #x4E05 #x4E06 #x4E0F #x4E12 #x4E17 #x4E1F #x4E20 #x4E21 #x4E23 #x4E26 #x4E29 #x4E2E #x4E2F #x4E31 #x4E33 #x4E35 #x4E37 #x4E3C #x4E40 #x4E41 #x4E42 #x4E44 #x4E46 #x4E4A #x4E51 #x4E55 #x4E57 #x4E5A #x4E5B #x4E62 #x4E63 #x4E64 #x4E65 #x4E67 #x4E68 #x4E6A #x4E6B #x4E6C #x4E6D #x4E6E #x4E6F #x4E72 #x4E74 #x4E75 #x4E76 #x4E77 #x4E78 #x4E79 #x4E7A #x4E7B #x4E7C #x4E7D #x4E7F #x4E80 #x4E81 #x4E82 #x4E83 #x4E84 #x4E85 #x4E87 #x4E8A #x4E90 #x4E96 #x4E97 #x4E99 #x4E9C #x4E9D #x4E9E #x4EA3 #x4EAA #x4EAF #x4EB0 #x4EB1 #x4EB4 #x4EB6 #x4EB7 #x4EB8 #x4EB9 #x4EBC #x4EBD #x4EBE #x4EC8 #x4ECC #x4ECF #x4ED0 #x4ED2 #x4EDA #x4EDB #x4EDC #x4EE0 #x4EE2 #x4EE6 #x4EE7 #x4EE9 #x4EED #x4EEE #x4EEF #x4EF1 #x4EF4 #x4EF8 #x4EF9 #x4EFA #x4EFC #x4EFE #x4F00 #x4F02 #x4F03 #x4F04 #x4F05 #x4F06 #x4F07 #x4F08 #x4F0B #x4F0C #x4F12 #x4F13 #x4F14 #x4F15 #x4F16 #x4F1C #x4F1D #x4F21 #x4F23 #x4F28 #x4F29 #x4F2C #x4F2D #x4F2E #x4F31 #x4F33 #x4F35 #x4F37 #x4F39 #x4F3B #x4F3E #x4F3F #x4F40 #x4F41 #x4F42 #x4F44 #x4F45 #x4F47 #x4F48 #x4F49 #x4F4A #x4F4B #x4F4C #x4F52 #x4F54 #x4F56 #x4F61 #x4F62 #x4F66 #x4F68 #x4F6A #x4F6B #x4F6D #x4F6E #x4F71 #x4F72 #x4F75 #x4F77 #x4F78 #x4F79 #x4F7A #x4F7D #x4F80 #x4F81 #x4F82 #x4F85 #x4F86 #x4F87 #x4F8A #x4F8C #x4F8E #x4F90 #x4F92 #x4F93 #x4F95 #x4F96 #x4F98 #x4F99 #x4F9A #x4F9C #x4F9E #x4F9F #x4FA1 #x4FA2 #x4FA4 #x4FAB #x4FAD #x4FB0 #x4FB1 #x4FB2 #x4FB3 #x4FB4 #x4FB6 #x4FB7 #x4FB8 #x4FB9 #x4FBA #x4FBB #x4FBC #x4FBD #x4FBE #x4FC0 #x4FC1 #x4FC2 #x4FC6 #x4FC7 #x4FC8 #x4FC9 #x4FCB #x4FCC #x4FCD #x4FD2 #x4FD3 #x4FD4 #x4FD5 #x4FD6 #x4FD9 #x4FDB #x4FE0 #x4FE2 #x4FE4 #x4FE5 #x4FE7 #x4FEB #x4FEC #x4FF0 #x4FF2 #x4FF4 #x4FF5 #x4FF6 #x4FF7 #x4FF9 #x4FFB #x4FFC #x4FFD #x4FFF #x5000 #x5001 #x5002 #x5003 #x5004 #x5005 #x5006 #x5007 #x5008 #x5009 #x500A #x500B #x500E #x5010 #x5011 #x5013 #x5015 #x5016 #x5017 #x501B #x501D #x501E #x5020 #x5022 #x5023 #x5024 #x5027 #x502B #x502F #x5030 #x5031 #x5032 #x5033 #x5034 #x5035 #x5036 #x5037 #x5038 #x5039 #x503B #x503D #x503F #x5040 #x5041 #x5042 #x5044 #x5045 #x5046 #x5049 #x504A #x504B #x504D #x5050 #x5051 #x5052 #x5053 #x5054 #x5056 #x5057 #x5058 #x5059 #x505B #x505D #x505E #x505F #x5060 #x5061 #x5062 #x5063 #x5064 #x5066 #x5067 #x5068 #x5069 #x506A #x506B #x506D #x506E #x506F #x5070 #x5071 #x5072 #x5073 #x5074 #x5075 #x5078 #x5079 #x507A #x507C #x507D #x5081 #x5082 #x5083 #x5084 #x5086 #x5087 #x5089 #x508A #x508B #x508C #x508E #x508F #x5090 #x5091 #x5092 #x5093 #x5094 #x5095 #x5096 #x5097 #x5098 #x5099 #x509A #x509B #x509C #x509D #x509E #x509F #x50A0 #x50A1 #x50A2 #x50A4 #x50A6 #x50AA #x50AB #x50AD #x50AE #x50AF #x50B0 #x50B1 #x50B3 #x50B4 #x50B5 #x50B6 #x50B7 #x50B8 #x50B9 #x50BC #x50BD #x50BE #x50BF #x50C0 #x50C1 #x50C2 #x50C3 #x50C4 #x50C5 #x50C6 #x50C7 #x50C8 #x50C9 #x50CA #x50CB #x50CC #x50CD #x50CE #x50D0 #x50D1 #x50D2 #x50D3 #x50D4 #x50D5 #x50D7 #x50D8 #x50D9 #x50DB #x50DC #x50DD #x50DE #x50DF #x50E0 #x50E1 #x50E2 #x50E3 #x50E4 #x50E5 #x50E8 #x50E9 #x50EA #x50EB #x50EF #x50F0 #x50F1 #x50F2 #x50F4 #x50F6 #x50F7 #x50F8 #x50F9 #x50FA #x50FC #x50FD #x50FE #x50FF #x5100 #x5101 #x5102 #x5103 #x5104 #x5105 #x5108 #x5109 #x510A #x510C #x510D #x510E #x510F #x5110 #x5111 #x5113 #x5114 #x5115 #x5116 #x5117 #x5118 #x5119 #x511A #x511B #x511C #x511D #x511E #x511F #x5120 #x5122 #x5123 #x5124 #x5125 #x5126 #x5127 #x5128 #x5129 #x512A #x512B #x512C #x512D #x512E #x512F #x5130 #x5131 #x5132 #x5133 #x5134 #x5135 #x5136 #x5137 #x5138 #x5139 #x513A #x513B #x513C #x513D #x513E #x5142 #x5147 #x514A #x514C #x514E #x514F #x5150 #x5152 #x5153 #x5157 #x5158 #x5159 #x515B #x515D #x515E #x515F #x5160 #x5161 #x5163 #x5164 #x5166 #x5167 #x5169 #x516A #x516F #x5172 #x517A #x517E #x517F #x5183 #x5184 #x5186 #x5187 #x518A #x518B #x518E #x518F #x5190 #x5191 #x5193 #x5194 #x5198 #x519A #x519D #x519E #x519F #x51A1 #x51A3 #x51A6 #x51A7 #x51A8 #x51A9 #x51AA #x51AD #x51AE #x51B4 #x51B8 #x51B9 #x51BA #x51BE #x51BF #x51C1 #x51C2 #x51C3 #x51C5 #x51C8 #x51CA #x51CD #x51CE #x51D0 #x51D2 #x51D3 #x51D4 #x51D5 #x51D6 #x51D7 #x51D8 #x51D9 #x51DA #x51DC #x51DE #x51DF #x51E2 #x51E3 #x51E5 #x51E6 #x51E7 #x51E8 #x51E9 #x51EA #x51EC #x51EE #x51F1 #x51F2 #x51F4 #x51F7 #x51FE #x5204 #x5205 #x5209 #x520B #x520C #x520F #x5210 #x5213 #x5214 #x5215 #x521C #x521E #x521F #x5221 #x5222 #x5223 #x5225 #x5226 #x5227 #x522A #x522C #x522F #x5231 #x5232 #x5234 #x5235 #x523C #x523E #x5244 #x5245 #x5246 #x5247 #x5248 #x5249 #x524B #x524E #x524F #x5252 #x5253 #x5255 #x5257 #x5258 #x5259 #x525A #x525B #x525D #x525F #x5260 #x5262 #x5263 #x5264 #x5266 #x5268 #x526B #x526C #x526D #x526E #x5270 #x5271 #x5273 #x5274 #x5275 #x5276 #x5277 #x5278 #x5279 #x527A #x527B #x527C #x527E #x5280 #x5283 #x5284 #x5285 #x5286 #x5287 #x5289 #x528A #x528B #x528C #x528D #x528E #x528F #x5291 #x5292 #x5294 #x5295 #x5296 #x5297 #x5298 #x5299 #x529A #x529C #x52A4 #x52A5 #x52A6 #x52A7 #x52AE #x52AF #x52B0 #x52B4 #x52B5 #x52B6 #x52B7 #x52B8 #x52B9 #x52BA #x52BB #x52BC #x52BD #x52C0 #x52C1 #x52C2 #x52C4 #x52C5 #x52C6 #x52C8 #x52CA #x52CC #x52CD #x52CE #x52CF #x52D1 #x52D3 #x52D4 #x52D5 #x52D7 #x52D9 #x52DA #x52DB #x52DC #x52DD #x52DE #x52E0 #x52E1 #x52E2 #x52E3 #x52E5 #x52E6 #x52E7 #x52E8 #x52E9 #x52EA #x52EB #x52EC #x52ED #x52EE #x52EF #x52F1 #x52F2 #x52F3 #x52F4 #x52F5 #x52F6 #x52F7 #x52F8 #x52FB #x52FC #x52FD #x5301 #x5302 #x5303 #x5304 #x5307 #x5309 #x530A #x530B #x530C #x530E #x5311 #x5312 #x5313 #x5314 #x5318 #x531B #x531C #x531E #x531F #x5322 #x5324 #x5325 #x5327 #x5328 #x5329 #x532B #x532C #x532D #x532F #x5330 #x5331 #x5332 #x5333 #x5334 #x5335 #x5336 #x5337 #x5338 #x533C #x533D #x5340 #x5342 #x5344 #x5346 #x534B #x534C #x534D #x5350 #x5354 #x5358 #x5359 #x535B #x535D #x5365 #x5368 #x536A #x536C #x536D #x5372 #x5376 #x5379 #x537B #x537C #x537D #x537E #x5380 #x5381 #x5383 #x5387 #x5388 #x538A #x538E #x538F #x5390 #x5391 #x5392 #x5393 #x5394 #x5396 #x5397 #x5399 #x539B #x539C #x539E #x53A0 #x53A1 #x53A4 #x53A7 #x53AA #x53AB #x53AC #x53AD #x53AF #x53B0 #x53B1 #x53B2 #x53B3 #x53B4 #x53B5 #x53B7 #x53B8 #x53B9 #x53BA #x53BC #x53BD #x53BE #x53C0 #x53C3 #x53C4 #x53C5 #x53C6 #x53C7 #x53CE #x53CF #x53D0 #x53D2 #x53D3 #x53D5 #x53DA #x53DC #x53DD #x53DE #x53E1 #x53E2 #x53E7 #x53F4 #x53FA #x53FE #x53FF #x5400 #x5402 #x5405 #x5407 #x540B #x5414 #x5418 #x5419 #x541A #x541C #x5422 #x5424 #x5425 #x542A #x5430 #x5433 #x5436 #x5437 #x543A #x543D #x543F #x5441 #x5442 #x5444 #x5445 #x5447 #x5449 #x544C #x544D #x544E #x544F #x5451 #x545A #x545D #x545E #x545F #x5460 #x5461 #x5463 #x5465 #x5467 #x5469 #x546A #x546B #x546C #x546D #x546E #x546F #x5470 #x5474 #x5479 #x547A #x547E #x547F #x5481 #x5483 #x5485 #x5487 #x5488 #x5489 #x548A #x548D #x5491 #x5493 #x5497 #x5498 #x549C #x549E #x549F #x54A0 #x54A1 #x54A2 #x54A5 #x54AE #x54B0 #x54B2 #x54B5 #x54B6 #x54B7 #x54B9 #x54BA #x54BC #x54BE #x54C3 #x54C5 #x54CA #x54CB #x54D6 #x54D8 #x54DB #x54E0 #x54E1 #x54E2 #x54E3 #x54E4 #x54EB #x54EC #x54EF #x54F0 #x54F1 #x54F4 #x54F5 #x54F6 #x54F7 #x54F8 #x54F9 #x54FB #x54FE #x5500 #x5502 #x5503 #x5504 #x5505 #x5508 #x550A #x550B #x550C #x550D #x550E #x5512 #x5513 #x5515 #x5516 #x5517 #x5518 #x5519 #x551A #x551C #x551D #x551E #x551F #x5521 #x5525 #x5526 #x5528 #x5529 #x552B #x552D #x5532 #x5534 #x5535 #x5536 #x5538 #x5539 #x553A #x553B #x553D #x5540 #x5542 #x5545 #x5547 #x5548 #x554B #x554C #x554D #x554E #x554F #x5551 #x5552 #x5553 #x5554 #x5557 #x5558 #x5559 #x555A #x555B #x555D #x555E #x555F #x5560 #x5562 #x5563 #x5568 #x5569 #x556B #x556F #x5570 #x5571 #x5572 #x5573 #x5574 #x5579 #x557A #x557D #x557F #x5585 #x5586 #x558C #x558D #x558E #x5590 #x5592 #x5593 #x5595 #x5596 #x5597 #x559A #x559B #x559E #x55A0 #x55A1 #x55A2 #x55A3 #x55A4 #x55A5 #x55A6 #x55A8 #x55A9 #x55AA #x55AB #x55AC #x55AD #x55AE #x55AF #x55B0 #x55B2 #x55B4 #x55B6 #x55B8 #x55BA #x55BC #x55BF #x55C0 #x55C1 #x55C2 #x55C3 #x55C6 #x55C7 #x55C8 #x55CA #x55CB #x55CE #x55CF #x55D0 #x55D5 #x55D7 #x55D8 #x55D9 #x55DA #x55DB #x55DE #x55E0 #x55E2 #x55E7 #x55E9 #x55ED #x55EE #x55F0 #x55F1 #x55F4 #x55F6 #x55F8 #x55F9 #x55FA #x55FB #x55FC #x55FF #x5602 #x5603 #x5604 #x5605 #x5606 #x5607 #x560A #x560B #x560D #x5610 #x5611 #x5612 #x5613 #x5614 #x5615 #x5616 #x5617 #x5619 #x561A #x561C #x561D #x5620 #x5621 #x5622 #x5625 #x5626 #x5628 #x5629 #x562A #x562B #x562E #x562F #x5630 #x5633 #x5635 #x5637 #x5638 #x563A #x563C #x563D #x563E #x5640 #x5641 #x5642 #x5643 #x5644 #x5645 #x5646 #x5647 #x5648 #x5649 #x564A #x564B #x564F #x5650 #x5651 #x5652 #x5653 #x5655 #x5656 #x565A #x565B #x565D #x565E #x565F #x5660 #x5661 #x5663 #x5665 #x5666 #x5667 #x566D #x566E #x566F #x5670 #x5672 #x5673 #x5674 #x5675 #x5677 #x5678 #x5679 #x567A #x567D #x567E #x567F #x5680 #x5681 #x5682 #x5683 #x5684 #x5687 #x5688 #x5689 #x568A #x568B #x568C #x568D #x5690 #x5691 #x5692 #x5694 #x5695 #x5696 #x5697 #x5698 #x5699 #x569A #x569B #x569C #x569D #x569E #x569F #x56A0 #x56A1 #x56A2 #x56A4 #x56A5 #x56A6 #x56A7 #x56A8 #x56A9 #x56AA #x56AB #x56AC #x56AD #x56AE #x56B0 #x56B1 #x56B2 #x56B3 #x56B4 #x56B5 #x56B6 #x56B8 #x56B9 #x56BA #x56BB #x56BD #x56BE #x56BF #x56C0 #x56C1 #x56C2 #x56C3 #x56C4 #x56C5 #x56C6 #x56C7 #x56C8 #x56C9 #x56CB #x56CC #x56CD #x56CE #x56CF #x56D0 #x56D1 #x56D2 #x56D3 #x56D5 #x56D6 #x56D8 #x56D9 #x56DC #x56E3 #x56E5 #x56E6 #x56E7 #x56E8 #x56E9 #x56EA #x56EC #x56EE #x56EF #x56F2 #x56F3 #x56F6 #x56F7 #x56F8 #x56FB #x56FC #x5700 #x5701 #x5702 #x5705 #x5707 #x570B #x570C #x570D #x570E #x570F #x5710 #x5711 #x5712 #x5713 #x5714 #x5715 #x5716 #x5717 #x5718 #x5719 #x571A #x571B #x571D #x571E #x5720 #x5721 #x5722 #x5724 #x5725 #x5726 #x5727 #x572B #x5731 #x5732 #x5734 #x5735 #x5736 #x5737 #x5738 #x573C #x573D #x573F #x5741 #x5743 #x5744 #x5745 #x5746 #x5748 #x5749 #x574B #x5752 #x5753 #x5754 #x5755 #x5756 #x5758 #x5759 #x5762 #x5763 #x5765 #x5767 #x576C #x576E #x5770 #x5771 #x5772 #x5774 #x5775 #x5778 #x5779 #x577A #x577D #x577E #x577F #x5780 #x5781 #x5787 #x5788 #x5789 #x578A #x578D #x578E #x578F #x5790 #x5791 #x5794 #x5795 #x5796 #x5797 #x5798 #x5799 #x579A #x579C #x579D #x579E #x579F #x57A5 #x57A8 #x57AA #x57AC #x57AF #x57B0 #x57B1 #x57B3 #x57B5 #x57B6 #x57B7 #x57B9 #x57BA #x57BB #x57BC #x57BD #x57BE #x57BF #x57C0 #x57C1 #x57C4 #x57C5 #x57C6 #x57C7 #x57C8 #x57C9 #x57CA #x57CC #x57CD #x57D0 #x57D1 #x57D3 #x57D6 #x57D7 #x57DB #x57DC #x57DE #x57E1 #x57E2 #x57E3 #x57E5 #x57E6 #x57E7 #x57E8 #x57E9 #x57EA #x57EB #x57EC #x57EE #x57F0 #x57F1 #x57F2 #x57F3 #x57F5 #x57F6 #x57F7 #x57FB #x57FC #x57FE #x57FF #x5801 #x5803 #x5804 #x5805 #x5808 #x5809 #x580A #x580C #x580E #x580F #x5810 #x5812 #x5813 #x5814 #x5816 #x5817 #x5818 #x581A #x581B #x581C #x581D #x581F #x5822 #x5823 #x5825 #x5826 #x5827 #x5828 #x5829 #x582B #x582C #x582D #x582E #x582F #x5831 #x5832 #x5833 #x5834 #x5836 #x5837 #x5838 #x5839 #x583A #x583B #x583C #x583D #x583E #x583F #x5840 #x5841 #x5842 #x5843 #x5845 #x5846 #x5847 #x5848 #x5849 #x584A #x584B #x584E #x584F #x5850 #x5852 #x5853 #x5855 #x5856 #x5857 #x5859 #x585A #x585B #x585C #x585D #x585F #x5860 #x5861 #x5862 #x5863 #x5864 #x5866 #x5867 #x5868 #x5869 #x586A #x586D #x586E #x586F #x5870 #x5871 #x5872 #x5873 #x5874 #x5875 #x5876 #x5877 #x5878 #x5879 #x587A #x587B #x587C #x587D #x587F #x5882 #x5884 #x5886 #x5887 #x5888 #x588A #x588B #x588C #x588D #x588E #x588F #x5890 #x5891 #x5894 #x5895 #x5896 #x5897 #x5898 #x589B #x589C #x589D #x58A0 #x58A1 #x58A2 #x58A3 #x58A4 #x58A5 #x58A6 #x58A7 #x58AA #x58AB #x58AC #x58AD #x58AE #x58AF #x58B0 #x58B1 #x58B2 #x58B3 #x58B4 #x58B5 #x58B6 #x58B7 #x58B8 #x58B9 #x58BA #x58BB #x58BD #x58BE #x58BF #x58C0 #x58C2 #x58C3 #x58C4 #x58C6 #x58C7 #x58C8 #x58C9 #x58CA #x58CB #x58CC #x58CD #x58CE #x58CF #x58D0 #x58D2 #x58D3 #x58D4 #x58D6 #x58D7 #x58D8 #x58D9 #x58DA #x58DB #x58DC #x58DD #x58DE #x58DF #x58E0 #x58E1 #x58E2 #x58E3 #x58E5 #x58E6 #x58E7 #x58E8 #x58E9 #x58EA #x58ED #x58EF #x58F1 #x58F2 #x58F4 #x58F5 #x58F7 #x58F8 #x58FA #x58FB #x58FC #x58FD #x58FE #x58FF #x5900 #x5901 #x5903 #x5905 #x5906 #x5908 #x5909 #x590A #x590B #x590C #x590E #x5910 #x5911 #x5912 #x5913 #x5917 #x5918 #x591B #x591D #x591E #x5920 #x5921 #x5922 #x5923 #x5926 #x5928 #x592C #x5930 #x5932 #x5933 #x5935 #x5936 #x593B #x593D #x593E #x593F #x5940 #x5943 #x5945 #x5946 #x594A #x594C #x594D #x5950 #x5952 #x5953 #x5959 #x595B #x595C #x595D #x595E #x595F #x5961 #x5963 #x5964 #x5966 #x5967 #x5968 #x5969 #x596A #x596B #x596C #x596D #x596E #x596F #x5970 #x5971 #x5972 #x5975 #x5977 #x597A #x597B #x597C #x597E #x597F #x5980 #x5985 #x5989 #x598B #x598C #x598E #x598F #x5990 #x5991 #x5994 #x5995 #x5998 #x599A #x599B #x599C #x599D #x599F #x59A0 #x59A1 #x59A2 #x59A6 #x59A7 #x59AC #x59AD #x59B0 #x59B1 #x59B3 #x59B4 #x59B5 #x59B6 #x59B7 #x59B8 #x59BA #x59BC #x59BD #x59BF #x59C0 #x59C1 #x59C2 #x59C3 #x59C4 #x59C5 #x59C7 #x59C8 #x59C9 #x59CC #x59CD #x59CE #x59CF #x59D5 #x59D6 #x59D9 #x59DB #x59DE #x59DF #x59E0 #x59E1 #x59E2 #x59E4 #x59E6 #x59E7 #x59E9 #x59EA #x59EB #x59ED #x59EE #x59EF #x59F0 #x59F1 #x59F2 #x59F3 #x59F4 #x59F5 #x59F6 #x59F7 #x59F8 #x59FA #x59FC #x59FD #x59FE #x5A00 #x5A02 #x5A0A #x5A0B #x5A0D #x5A0E #x5A0F #x5A10 #x5A12 #x5A14 #x5A15 #x5A16 #x5A17 #x5A19 #x5A1A #x5A1B #x5A1D #x5A1E #x5A21 #x5A22 #x5A24 #x5A26 #x5A27 #x5A28 #x5A2A #x5A2B #x5A2C #x5A2D #x5A2E #x5A2F #x5A30 #x5A33 #x5A35 #x5A37 #x5A38 #x5A39 #x5A3A #x5A3B #x5A3D #x5A3E #x5A3F #x5A41 #x5A42 #x5A43 #x5A44 #x5A45 #x5A47 #x5A48 #x5A4B #x5A4C #x5A4D #x5A4E #x5A4F #x5A50 #x5A51 #x5A52 #x5A53 #x5A54 #x5A56 #x5A57 #x5A58 #x5A59 #x5A5B #x5A5C #x5A5D #x5A5E #x5A5F #x5A60 #x5A61 #x5A63 #x5A64 #x5A65 #x5A66 #x5A68 #x5A69 #x5A6B #x5A6C #x5A6D #x5A6E #x5A6F #x5A70 #x5A71 #x5A72 #x5A73 #x5A78 #x5A79 #x5A7B #x5A7C #x5A7D #x5A7E #x5A80 #x5A81 #x5A82 #x5A83 #x5A84 #x5A85 #x5A86 #x5A87 #x5A88 #x5A89 #x5A8A #x5A8B #x5A8C #x5A8D #x5A8E #x5A8F #x5A90 #x5A91 #x5A93 #x5A94 #x5A95 #x5A96 #x5A97 #x5A98 #x5A99 #x5A9C #x5A9D #x5A9E #x5A9F #x5AA0 #x5AA1 #x5AA2 #x5AA3 #x5AA4 #x5AA5 #x5AA6 #x5AA7 #x5AA8 #x5AA9 #x5AAB #x5AAC #x5AAD #x5AAE #x5AAF #x5AB0 #x5AB1 #x5AB4 #x5AB6 #x5AB7 #x5AB9 #x5ABA #x5ABB #x5ABC #x5ABD #x5ABF #x5AC0 #x5AC3 #x5AC4 #x5AC5 #x5AC6 #x5AC7 #x5AC8 #x5ACA #x5ACB #x5ACD #x5ACE #x5ACF #x5AD0 #x5AD1 #x5AD3 #x5AD5 #x5AD7 #x5AD9 #x5ADA #x5ADB #x5ADD #x5ADE #x5ADF #x5AE2 #x5AE4 #x5AE5 #x5AE7 #x5AE8 #x5AEA #x5AEC #x5AED #x5AEE #x5AEF #x5AF0 #x5AF2 #x5AF3 #x5AF4 #x5AF5 #x5AF6 #x5AF7 #x5AF8 #x5AF9 #x5AFA #x5AFB #x5AFC #x5AFD #x5AFE #x5AFF #x5B00 #x5B01 #x5B02 #x5B03 #x5B04 #x5B05 #x5B06 #x5B07 #x5B08 #x5B0A #x5B0B #x5B0C #x5B0D #x5B0E #x5B0F #x5B10 #x5B11 #x5B12 #x5B13 #x5B14 #x5B15 #x5B18 #x5B19 #x5B1A #x5B1B #x5B1C #x5B1D #x5B1E #x5B1F #x5B20 #x5B21 #x5B22 #x5B23 #x5B24 #x5B25 #x5B26 #x5B27 #x5B28 #x5B29 #x5B2A #x5B2B #x5B2C #x5B2D #x5B2E #x5B2F #x5B30 #x5B31 #x5B33 #x5B35 #x5B36 #x5B38 #x5B39 #x5B3A #x5B3B #x5B3C #x5B3D #x5B3E #x5B3F #x5B41 #x5B42 #x5B43 #x5B44 #x5B45 #x5B46 #x5B47 #x5B48 #x5B49 #x5B4A #x5B4B #x5B4C #x5B4D #x5B4E #x5B4F #x5B52 #x5B56 #x5B5E #x5B60 #x5B61 #x5B67 #x5B68 #x5B6B #x5B6D #x5B6E #x5B6F #x5B72 #x5B74 #x5B76 #x5B77 #x5B78 #x5B79 #x5B7B #x5B7C #x5B7E #x5B7F #x5B82 #x5B86 #x5B8A #x5B8D #x5B8E #x5B90 #x5B91 #x5B92 #x5B94 #x5B96 #x5B9F #x5BA7 #x5BA8 #x5BA9 #x5BAC #x5BAD #x5BAE #x5BAF #x5BB1 #x5BB2 #x5BB7 #x5BBA #x5BBB #x5BBC #x5BC0 #x5BC1 #x5BC3 #x5BC8 #x5BC9 #x5BCA #x5BCB #x5BCD #x5BCE #x5BCF #x5BD1 #x5BD4 #x5BD5 #x5BD6 #x5BD7 #x5BD8 #x5BD9 #x5BDA #x5BDB #x5BDC #x5BE0 #x5BE2 #x5BE3 #x5BE6 #x5BE7 #x5BE9 #x5BEA #x5BEB #x5BEC #x5BED #x5BEF #x5BF1 #x5BF2 #x5BF3 #x5BF4 #x5BF5 #x5BF6 #x5BF7 #x5BFD #x5BFE #x5C00 #x5C02 #x5C03 #x5C05 #x5C07 #x5C08 #x5C0B #x5C0C #x5C0D #x5C0E #x5C10 #x5C12 #x5C13 #x5C17 #x5C19 #x5C1B #x5C1E #x5C1F #x5C20 #x5C21 #x5C23 #x5C26 #x5C28 #x5C29 #x5C2A #x5C2B #x5C2D #x5C2E #x5C2F #x5C30 #x5C32 #x5C33 #x5C35 #x5C36 #x5C37 #x5C43 #x5C44 #x5C46 #x5C47 #x5C4C #x5C4D #x5C52 #x5C53 #x5C54 #x5C56 #x5C57 #x5C58 #x5C5A #x5C5B #x5C5C #x5C5D #x5C5F #x5C62 #x5C64 #x5C67 #x5C68 #x5C69 #x5C6A #x5C6B #x5C6C #x5C6D #x5C70 #x5C72 #x5C73 #x5C74 #x5C75 #x5C76 #x5C77 #x5C78 #x5C7B #x5C7C #x5C7D #x5C7E #x5C80 #x5C83 #x5C84 #x5C85 #x5C86 #x5C87 #x5C89 #x5C8A #x5C8B #x5C8E #x5C8F #x5C92 #x5C93 #x5C95 #x5C9D #x5C9E #x5C9F #x5CA0 #x5CA1 #x5CA4 #x5CA5 #x5CA6 #x5CA7 #x5CA8 #x5CAA #x5CAE #x5CAF #x5CB0 #x5CB2 #x5CB4 #x5CB6 #x5CB9 #x5CBA #x5CBB #x5CBC #x5CBE #x5CC0 #x5CC2 #x5CC3 #x5CC5 #x5CC6 #x5CC7 #x5CC8 #x5CC9 #x5CCA #x5CCC #x5CCD #x5CCE #x5CCF #x5CD0 #x5CD1 #x5CD3 #x5CD4 #x5CD5 #x5CD6 #x5CD7 #x5CD8 #x5CDA #x5CDB #x5CDC #x5CDD #x5CDE #x5CDF #x5CE0 #x5CE2 #x5CE3 #x5CE7 #x5CE9 #x5CEB #x5CEC #x5CEE #x5CEF #x5CF1 #x5CF2 #x5CF3 #x5CF4 #x5CF5 #x5CF6 #x5CF7 #x5CF8 #x5CF9 #x5CFA #x5CFC #x5CFD #x5CFE #x5CFF #x5D00 #x5D01 #x5D04 #x5D05 #x5D08 #x5D09 #x5D0A #x5D0B #x5D0C #x5D0D #x5D0F #x5D10 #x5D11 #x5D12 #x5D13 #x5D15 #x5D17 #x5D18 #x5D19 #x5D1A #x5D1C #x5D1D #x5D1F #x5D20 #x5D21 #x5D22 #x5D23 #x5D25 #x5D28 #x5D2A #x5D2B #x5D2C #x5D2F #x5D30 #x5D31 #x5D32 #x5D33 #x5D35 #x5D36 #x5D37 #x5D38 #x5D39 #x5D3A #x5D3B #x5D3C #x5D3F #x5D40 #x5D41 #x5D42 #x5D43 #x5D44 #x5D45 #x5D46 #x5D48 #x5D49 #x5D4D #x5D4E #x5D4F #x5D50 #x5D51 #x5D52 #x5D53 #x5D54 #x5D55 #x5D56 #x5D57 #x5D59 #x5D5A #x5D5C #x5D5E #x5D5F #x5D60 #x5D61 #x5D62 #x5D63 #x5D64 #x5D65 #x5D66 #x5D67 #x5D68 #x5D6A #x5D6D #x5D6E #x5D70 #x5D71 #x5D72 #x5D73 #x5D75 #x5D76 #x5D77 #x5D78 #x5D79 #x5D7A #x5D7B #x5D7C #x5D7D #x5D7E #x5D7F #x5D80 #x5D81 #x5D83 #x5D84 #x5D85 #x5D86 #x5D87 #x5D88 #x5D89 #x5D8A #x5D8B #x5D8C #x5D8D #x5D8E #x5D8F #x5D90 #x5D91 #x5D92 #x5D93 #x5D94 #x5D95 #x5D96 #x5D97 #x5D98 #x5D9A #x5D9B #x5D9C #x5D9E #x5D9F #x5DA0 #x5DA1 #x5DA2 #x5DA3 #x5DA4 #x5DA5 #x5DA6 #x5DA7 #x5DA8 #x5DA9 #x5DAA #x5DAB #x5DAC #x5DAD #x5DAE #x5DAF #x5DB0 #x5DB1 #x5DB2 #x5DB3 #x5DB4 #x5DB5 #x5DB6 #x5DB8 #x5DB9 #x5DBA #x5DBB #x5DBC #x5DBD #x5DBE #x5DBF #x5DC0 #x5DC1 #x5DC2 #x5DC3 #x5DC4 #x5DC6 #x5DC7 #x5DC8 #x5DC9 #x5DCA #x5DCB #x5DCC #x5DCE #x5DCF #x5DD0 #x5DD1 #x5DD2 #x5DD3 #x5DD4 #x5DD5 #x5DD6 #x5DD7 #x5DD8 #x5DD9 #x5DDA #x5DDC #x5DDF #x5DE0 #x5DE3 #x5DE4 #x5DEA #x5DEC #x5DED #x5DF0 #x5DF5 #x5DF6 #x5DF8 #x5DF9 #x5DFA #x5DFB #x5DFC #x5DFF #x5E00 #x5E04 #x5E07 #x5E09 #x5E0A #x5E0B #x5E0D #x5E0E #x5E12 #x5E13 #x5E17 #x5E1E #x5E1F #x5E20 #x5E21 #x5E22 #x5E23 #x5E24 #x5E25 #x5E28 #x5E29 #x5E2A #x5E2B #x5E2C #x5E2F #x5E30 #x5E32 #x5E33 #x5E34 #x5E35 #x5E36 #x5E39 #x5E3A #x5E3E #x5E3F #x5E40 #x5E41 #x5E43 #x5E46 #x5E47 #x5E48 #x5E49 #x5E4A #x5E4B #x5E4D #x5E4E #x5E4F #x5E50 #x5E51 #x5E52 #x5E53 #x5E56 #x5E57 #x5E58 #x5E59 #x5E5A #x5E5C #x5E5D #x5E5F #x5E60 #x5E63 #x5E64 #x5E65 #x5E66 #x5E67 #x5E68 #x5E69 #x5E6A #x5E6B #x5E6C #x5E6D #x5E6E #x5E6F #x5E70 #x5E71 #x5E75 #x5E77 #x5E79 #x5E7E #x5E81 #x5E82 #x5E83 #x5E85 #x5E88 #x5E89 #x5E8C #x5E8D #x5E8E #x5E92 #x5E98 #x5E9B #x5E9D #x5EA1 #x5EA2 #x5EA3 #x5EA4 #x5EA8 #x5EA9 #x5EAA #x5EAB #x5EAC #x5EAE #x5EAF #x5EB0 #x5EB1 #x5EB2 #x5EB4 #x5EBA #x5EBB #x5EBC #x5EBD #x5EBF #x5EC0 #x5EC1 #x5EC2 #x5EC3 #x5EC4 #x5EC5 #x5EC6 #x5EC7 #x5EC8 #x5ECB #x5ECC #x5ECD #x5ECE #x5ECF #x5ED0 #x5ED4 #x5ED5 #x5ED7 #x5ED8 #x5ED9 #x5EDA #x5EDC #x5EDD #x5EDE #x5EDF #x5EE0 #x5EE1 #x5EE2 #x5EE3 #x5EE4 #x5EE5 #x5EE6 #x5EE7 #x5EE9 #x5EEB #x5EEC #x5EED #x5EEE #x5EEF #x5EF0 #x5EF1 #x5EF2 #x5EF3 #x5EF5 #x5EF8 #x5EF9 #x5EFB #x5EFC #x5EFD #x5F05 #x5F06 #x5F07 #x5F09 #x5F0C #x5F0D #x5F0E #x5F10 #x5F12 #x5F14 #x5F16 #x5F19 #x5F1A #x5F1C #x5F1D #x5F1E #x5F21 #x5F22 #x5F23 #x5F24 #x5F28 #x5F2B #x5F2C #x5F2E #x5F30 #x5F32 #x5F33 #x5F34 #x5F35 #x5F36 #x5F37 #x5F38 #x5F3B #x5F3D #x5F3E #x5F3F #x5F41 #x5F42 #x5F43 #x5F44 #x5F45 #x5F46 #x5F47 #x5F48 #x5F49 #x5F4A #x5F4B #x5F4C #x5F4D #x5F4E #x5F4F #x5F51 #x5F54 #x5F59 #x5F5A #x5F5B #x5F5C #x5F5E #x5F5F #x5F60 #x5F63 #x5F65 #x5F67 #x5F68 #x5F6B #x5F6E #x5F6F #x5F72 #x5F74 #x5F75 #x5F76 #x5F78 #x5F7A #x5F7D #x5F7E #x5F7F #x5F83 #x5F86 #x5F8D #x5F8E #x5F8F #x5F91 #x5F93 #x5F94 #x5F96 #x5F9A #x5F9B #x5F9D #x5F9E #x5F9F #x5FA0 #x5FA2 #x5FA3 #x5FA4 #x5FA5 #x5FA6 #x5FA7 #x5FA9 #x5FAB #x5FAC #x5FAF #x5FB0 #x5FB1 #x5FB2 #x5FB3 #x5FB4 #x5FB6 #x5FB8 #x5FB9 #x5FBA #x5FBB #x5FBE #x5FBF #x5FC0 #x5FC1 #x5FC2 #x5FC7 #x5FC8 #x5FCA #x5FCB #x5FCE #x5FD3 #x5FD4 #x5FD5 #x5FDA #x5FDB #x5FDC #x5FDE #x5FDF #x5FE2 #x5FE3 #x5FE5 #x5FE6 #x5FE8 #x5FE9 #x5FEC #x5FEF #x5FF0 #x5FF2 #x5FF3 #x5FF4 #x5FF6 #x5FF7 #x5FF9 #x5FFA #x5FFC #x6007 #x6008 #x6009 #x600B #x600C #x6010 #x6011 #x6013 #x6017 #x6018 #x601A #x601E #x601F #x6022 #x6023 #x6024 #x602C #x602D #x602E #x6030 #x6031 #x6032 #x6033 #x6034 #x6036 #x6037 #x6038 #x6039 #x603A #x603D #x603E #x6040 #x6044 #x6045 #x6046 #x6047 #x6048 #x6049 #x604A #x604C #x604E #x604F #x6051 #x6053 #x6054 #x6056 #x6057 #x6058 #x605B #x605C #x605E #x605F #x6060 #x6061 #x6065 #x6066 #x606E #x6071 #x6072 #x6074 #x6075 #x6077 #x607E #x6080 #x6081 #x6082 #x6085 #x6086 #x6087 #x6088 #x608A #x608B #x608E #x608F #x6090 #x6091 #x6093 #x6095 #x6097 #x6098 #x6099 #x609C #x609E #x60A1 #x60A2 #x60A4 #x60A5 #x60A7 #x60A9 #x60AA #x60AE #x60B0 #x60B3 #x60B5 #x60B6 #x60B7 #x60B9 #x60BA #x60BD #x60BE #x60BF #x60C0 #x60C1 #x60C2 #x60C3 #x60C4 #x60C7 #x60C8 #x60C9 #x60CC #x60CD #x60CE #x60CF #x60D0 #x60D2 #x60D3 #x60D4 #x60D6 #x60D7 #x60D9 #x60DB #x60DE #x60E1 #x60E2 #x60E3 #x60E4 #x60E5 #x60EA #x60F1 #x60F2 #x60F5 #x60F7 #x60F8 #x60FB #x60FC #x60FD #x60FE #x60FF #x6102 #x6103 #x6104 #x6105 #x6107 #x610A #x610B #x610C #x6110 #x6111 #x6112 #x6113 #x6114 #x6116 #x6117 #x6118 #x6119 #x611B #x611C #x611D #x611E #x6121 #x6122 #x6125 #x6128 #x6129 #x612A #x612C #x612D #x612E #x612F #x6130 #x6131 #x6132 #x6133 #x6134 #x6135 #x6136 #x6137 #x6138 #x6139 #x613A #x613B #x613C #x613D #x613E #x6140 #x6141 #x6142 #x6143 #x6144 #x6145 #x6146 #x6147 #x6149 #x614B #x614D #x614F #x6150 #x6152 #x6153 #x6154 #x6156 #x6157 #x6158 #x6159 #x615A #x615B #x615C #x615E #x615F #x6160 #x6161 #x6163 #x6164 #x6165 #x6166 #x6169 #x616A #x616B #x616C #x616D #x616E #x616F #x6171 #x6172 #x6173 #x6174 #x6176 #x6178 #x6179 #x617A #x617B #x617C #x617D #x617E #x617F #x6180 #x6181 #x6182 #x6183 #x6184 #x6185 #x6186 #x6187 #x6188 #x6189 #x618A #x618C #x618D #x618F #x6190 #x6191 #x6192 #x6193 #x6195 #x6196 #x6197 #x6198 #x6199 #x619A #x619B #x619C #x619E #x619F #x61A0 #x61A1 #x61A2 #x61A3 #x61A4 #x61A5 #x61A6 #x61AA #x61AB #x61AD #x61AE #x61AF #x61B0 #x61B1 #x61B2 #x61B3 #x61B4 #x61B5 #x61B6 #x61B8 #x61B9 #x61BA #x61BB #x61BC #x61BD #x61BF #x61C0 #x61C1 #x61C3 #x61C4 #x61C5 #x61C6 #x61C7 #x61C9 #x61CC #x61CD #x61CE #x61CF #x61D0 #x61D3 #x61D5 #x61D6 #x61D7 #x61D8 #x61D9 #x61DA #x61DB #x61DC #x61DD #x61DE #x61DF #x61E0 #x61E1 #x61E2 #x61E3 #x61E4 #x61E5 #x61E7 #x61E8 #x61E9 #x61EA #x61EB #x61EC #x61ED #x61EE #x61EF #x61F0 #x61F1 #x61F2 #x61F3 #x61F4 #x61F6 #x61F7 #x61F8 #x61F9 #x61FA #x61FB #x61FC #x61FD #x61FE #x6200 #x6201 #x6202 #x6203 #x6204 #x6205 #x6207 #x6209 #x6213 #x6214 #x6219 #x621C #x621D #x621E #x6220 #x6223 #x6226 #x6227 #x6228 #x6229 #x622B #x622D #x622F #x6230 #x6231 #x6232 #x6235 #x6236 #x6238 #x6239 #x623A #x623B #x623C #x6242 #x6244 #x6245 #x6246 #x624A #x624F #x6250 #x6255 #x6256 #x6257 #x6259 #x625A #x625C #x625D #x625E #x625F #x6260 #x6261 #x6262 #x6264 #x6265 #x6268 #x6271 #x6272 #x6274 #x6275 #x6277 #x6278 #x627A #x627B #x627D #x6281 #x6282 #x6283 #x6285 #x6286 #x6287 #x6288 #x628B #x628C #x628D #x628E #x628F #x6290 #x6294 #x6299 #x629C #x629D #x629E #x62A3 #x62A6 #x62A7 #x62A9 #x62AA #x62AD #x62AE #x62AF #x62B0 #x62B2 #x62B3 #x62B4 #x62B6 #x62B7 #x62B8 #x62BA #x62BE #x62C0 #x62C1 #x62C3 #x62CB #x62CF #x62D1 #x62D5 #x62DD #x62DE #x62E0 #x62E1 #x62E4 #x62EA #x62EB #x62F0 #x62F2 #x62F5 #x62F8 #x62F9 #x62FA #x62FB #x6300 #x6303 #x6304 #x6305 #x6306 #x630A #x630B #x630C #x630D #x630F #x6310 #x6312 #x6313 #x6314 #x6315 #x6317 #x6318 #x6319 #x631C #x6326 #x6327 #x6329 #x632C #x632D #x632E #x6330 #x6331 #x6333 #x6334 #x6335 #x6336 #x6337 #x6338 #x633B #x633C #x633E #x633F #x6340 #x6341 #x6344 #x6347 #x6348 #x634A #x6351 #x6352 #x6353 #x6354 #x6356 #x6357 #x6358 #x6359 #x635A #x635B #x635C #x635D #x6360 #x6364 #x6365 #x6366 #x6368 #x636A #x636B #x636C #x636F #x6370 #x6372 #x6373 #x6374 #x6375 #x6378 #x6379 #x637C #x637D #x637E #x637F #x6381 #x6383 #x6384 #x6385 #x6386 #x638B #x638D #x6391 #x6393 #x6394 #x6395 #x6397 #x6399 #x639A #x639B #x639C #x639D #x639E #x639F #x63A1 #x63A4 #x63A6 #x63AB #x63AF #x63B1 #x63B2 #x63B5 #x63B6 #x63B9 #x63BB #x63BD #x63BF #x63C0 #x63C1 #x63C2 #x63C3 #x63C5 #x63C7 #x63C8 #x63CA #x63CB #x63CC #x63D1 #x63D3 #x63D4 #x63D5 #x63D7 #x63D8 #x63D9 #x63DA #x63DB #x63DC #x63DD #x63DF #x63E2 #x63E4 #x63E5 #x63E6 #x63E7 #x63E8 #x63EB #x63EC #x63EE #x63EF #x63F0 #x63F1 #x63F3 #x63F5 #x63F7 #x63F9 #x63FA #x63FB #x63FC #x63FE #x6403 #x6404 #x6406 #x6407 #x6408 #x6409 #x640A #x640D #x640E #x6411 #x6412 #x6415 #x6416 #x6417 #x6418 #x6419 #x641A #x641D #x641F #x6422 #x6423 #x6424 #x6425 #x6427 #x6428 #x6429 #x642B #x642E #x642F #x6430 #x6431 #x6432 #x6433 #x6435 #x6436 #x6437 #x6438 #x6439 #x643B #x643C #x643E #x6440 #x6442 #x6443 #x6449 #x644B #x644C #x644D #x644E #x644F #x6450 #x6451 #x6453 #x6455 #x6456 #x6457 #x6459 #x645A #x645B #x645C #x645D #x645F #x6460 #x6461 #x6462 #x6463 #x6464 #x6465 #x6466 #x6468 #x646A #x646B #x646C #x646E #x646F #x6470 #x6471 #x6472 #x6473 #x6474 #x6475 #x6476 #x6477 #x647B #x647C #x647D #x647E #x647F #x6480 #x6481 #x6483 #x6486 #x6488 #x6489 #x648A #x648B #x648C #x648D #x648E #x648F #x6490 #x6493 #x6494 #x6497 #x6498 #x649A #x649B #x649C #x649D #x649F #x64A0 #x64A1 #x64A2 #x64A3 #x64A5 #x64A6 #x64A7 #x64A8 #x64AA #x64AB #x64AF #x64B1 #x64B2 #x64B3 #x64B4 #x64B6 #x64B9 #x64BB #x64BD #x64BE #x64BF #x64C1 #x64C3 #x64C4 #x64C6 #x64C7 #x64C8 #x64C9 #x64CA #x64CB #x64CC #x64CF #x64D1 #x64D3 #x64D4 #x64D5 #x64D6 #x64D9 #x64DA #x64DB #x64DC #x64DD #x64DF #x64E0 #x64E1 #x64E3 #x64E5 #x64E7 #x64E8 #x64E9 #x64EA #x64EB #x64EC #x64ED #x64EE #x64EF #x64F0 #x64F1 #x64F2 #x64F3 #x64F4 #x64F5 #x64F6 #x64F7 #x64F8 #x64F9 #x64FA #x64FB #x64FC #x64FD #x64FE #x64FF #x6501 #x6502 #x6503 #x6504 #x6505 #x6506 #x6507 #x6508 #x650A #x650B #x650C #x650D #x650E #x650F #x6510 #x6511 #x6513 #x6514 #x6515 #x6516 #x6517 #x6519 #x651A #x651B #x651C #x651D #x651E #x651F #x6520 #x6521 #x6522 #x6523 #x6524 #x6526 #x6527 #x6528 #x6529 #x652A #x652C #x652D #x6530 #x6531 #x6532 #x6533 #x6537 #x653A #x653C #x653D #x6540 #x6541 #x6542 #x6543 #x6544 #x6546 #x6547 #x654A #x654B #x654D #x654E #x6550 #x6552 #x6553 #x6554 #x6557 #x6558 #x655A #x655C #x655F #x6560 #x6561 #x6564 #x6565 #x6567 #x6568 #x6569 #x656A #x656D #x656E #x656F #x6571 #x6573 #x6575 #x6576 #x6578 #x6579 #x657A #x657B #x657C #x657D #x657E #x657F #x6580 #x6581 #x6582 #x6583 #x6584 #x6585 #x6586 #x6588 #x6589 #x658A #x658D #x658E #x658F #x6592 #x6594 #x6595 #x6596 #x6598 #x659A #x659D #x659E #x65A0 #x65A2 #x65A3 #x65A6 #x65A8 #x65AA #x65AC #x65AE #x65B1 #x65B2 #x65B3 #x65B4 #x65B5 #x65B6 #x65B7 #x65B8 #x65BA #x65BB #x65BE #x65BF #x65C0 #x65C2 #x65C7 #x65C8 #x65C9 #x65CA #x65CD #x65D0 #x65D1 #x65D3 #x65D4 #x65D5 #x65D8 #x65D9 #x65DA #x65DB #x65DC #x65DD #x65DE #x65DF #x65E1 #x65E3 #x65E4 #x65EA #x65EB #x65F2 #x65F3 #x65F4 #x65F5 #x65F8 #x65F9 #x65FB #x65FC #x65FD #x65FE #x65FF #x6601 #x6604 #x6605 #x6607 #x6608 #x6609 #x660B #x660D #x6610 #x6611 #x6612 #x6616 #x6617 #x6618 #x661A #x661B #x661C #x661E #x6621 #x6622 #x6623 #x6624 #x6626 #x6629 #x662A #x662B #x662C #x662E #x6630 #x6632 #x6633 #x6637 #x6638 #x6639 #x663A #x663B #x663D #x663F #x6640 #x6642 #x6644 #x6645 #x6646 #x6647 #x6648 #x6649 #x664A #x664D #x664E #x6650 #x6651 #x6658 #x6659 #x665B #x665C #x665D #x665E #x6660 #x6662 #x6663 #x6665 #x6667 #x6669 #x666A #x666B #x666C #x666D #x6671 #x6672 #x6673 #x6675 #x6678 #x6679 #x667B #x667C #x667D #x667F #x6680 #x6681 #x6683 #x6685 #x6686 #x6688 #x6689 #x668A #x668B #x668D #x668E #x668F #x6690 #x6692 #x6693 #x6694 #x6695 #x6698 #x6699 #x669A #x669B #x669C #x669E #x669F #x66A0 #x66A1 #x66A2 #x66A3 #x66A4 #x66A5 #x66A6 #x66A9 #x66AA #x66AB #x66AC #x66AD #x66AF #x66B0 #x66B1 #x66B2 #x66B3 #x66B5 #x66B6 #x66B7 #x66B8 #x66BA #x66BB #x66BC #x66BD #x66BF #x66C0 #x66C1 #x66C2 #x66C3 #x66C4 #x66C5 #x66C6 #x66C7 #x66C8 #x66C9 #x66CA #x66CB #x66CC #x66CD #x66CE #x66CF #x66D0 #x66D1 #x66D2 #x66D3 #x66D4 #x66D5 #x66D6 #x66D7 #x66D8 #x66DA #x66DE #x66DF #x66E0 #x66E1 #x66E2 #x66E3 #x66E4 #x66E5 #x66E7 #x66E8 #x66EA #x66EB #x66EC #x66ED #x66EE #x66EF #x66F1 #x66F5 #x66F6 #x66F8 #x66FA #x66FB #x66FD #x6701 #x6702 #x6703 #x6704 #x6705 #x6706 #x6707 #x670C #x670E #x670F #x6711 #x6712 #x6713 #x6716 #x6718 #x6719 #x671A #x671C #x671E #x6720 #x6721 #x6722 #x6723 #x6724 #x6725 #x6727 #x6729 #x672E #x6730 #x6732 #x6733 #x6736 #x6737 #x6738 #x6739 #x673B #x673C #x673E #x673F #x6741 #x6744 #x6745 #x6747 #x674A #x674B #x674D #x6752 #x6754 #x6755 #x6757 #x6758 #x6759 #x675A #x675B #x675D #x6762 #x6763 #x6764 #x6766 #x6767 #x676B #x676C #x676E #x6771 #x6774 #x6776 #x6778 #x6779 #x677A #x677B #x677D #x6780 #x6782 #x6783 #x6785 #x6786 #x6788 #x678A #x678C #x678D #x678E #x678F #x6791 #x6792 #x6793 #x6794 #x6796 #x6799 #x679B #x679F #x67A0 #x67A1 #x67A4 #x67A6 #x67A9 #x67AC #x67AE #x67B1 #x67B2 #x67B4 #x67B9 #x67BA #x67BB #x67BC #x67BD #x67BE #x67BF #x67C0 #x67C2 #x67C5 #x67C6 #x67C7 #x67C8 #x67C9 #x67CA #x67CB #x67CC #x67CD #x67CE #x67D5 #x67D6 #x67D7 #x67DB #x67DF #x67E1 #x67E3 #x67E4 #x67E6 #x67E7 #x67E8 #x67EA #x67EB #x67ED #x67EE #x67F2 #x67F5 #x67F6 #x67F7 #x67F8 #x67F9 #x67FA #x67FB #x67FC #x67FE #x6801 #x6802 #x6803 #x6804 #x6806 #x680D #x6810 #x6812 #x6814 #x6815 #x6818 #x6819 #x681A #x681B #x681C #x681E #x681F #x6820 #x6822 #x6823 #x6824 #x6825 #x6826 #x6827 #x6828 #x682B #x682C #x682D #x682E #x682F #x6830 #x6831 #x6834 #x6835 #x6836 #x683A #x683B #x683F #x6847 #x684B #x684D #x684F #x6852 #x6856 #x6857 #x6858 #x6859 #x685A #x685B #x685C #x685D #x685E #x685F #x686A #x686C #x686D #x686E #x686F #x6870 #x6871 #x6872 #x6873 #x6875 #x6878 #x6879 #x687A #x687B #x687C #x687D #x687E #x687F #x6880 #x6882 #x6884 #x6887 #x6888 #x6889 #x688A #x688B #x688C #x688D #x688E #x6890 #x6891 #x6892 #x6894 #x6895 #x6896 #x6898 #x6899 #x689A #x689B #x689C #x689D #x689E #x689F #x68A0 #x68A1 #x68A3 #x68A4 #x68A5 #x68A9 #x68AA #x68AB #x68AC #x68AE #x68B1 #x68B2 #x68B4 #x68B6 #x68B7 #x68B8 #x68B9 #x68BA #x68BB #x68BC #x68BD #x68BE #x68BF #x68C1 #x68C3 #x68C4 #x68C5 #x68C6 #x68C7 #x68C8 #x68CA #x68CC #x68CE #x68CF #x68D0 #x68D1 #x68D3 #x68D4 #x68D6 #x68D7 #x68D9 #x68DB #x68DC #x68DD #x68DE #x68DF #x68E1 #x68E2 #x68E4 #x68E5 #x68E6 #x68E7 #x68E8 #x68E9 #x68EA #x68EB #x68EC #x68ED #x68EF #x68F2 #x68F3 #x68F4 #x68F6 #x68F7 #x68F8 #x68FB #x68FD #x68FE #x68FF #x6900 #x6902 #x6903 #x6904 #x6906 #x6907 #x6908 #x6909 #x690A #x690C #x690F #x6911 #x6913 #x6914 #x6915 #x6916 #x6917 #x6918 #x6919 #x691A #x691B #x691C #x691D #x691E #x6921 #x6922 #x6923 #x6925 #x6926 #x6927 #x6928 #x6929 #x692A #x692B #x692C #x692E #x692F #x6931 #x6932 #x6933 #x6935 #x6936 #x6937 #x6938 #x693A #x693B #x693C #x693E #x6940 #x6941 #x6943 #x6944 #x6945 #x6946 #x6947 #x6948 #x6949 #x694A #x694B #x694C #x694D #x694E #x694F #x6950 #x6951 #x6952 #x6953 #x6955 #x6956 #x6958 #x6959 #x695B #x695C #x695F #x6961 #x6962 #x6964 #x6965 #x6967 #x6968 #x6969 #x696A #x696C #x696D #x696F #x6970 #x6972 #x6973 #x6974 #x6975 #x6976 #x697A #x697B #x697D #x697E #x697F #x6981 #x6983 #x6985 #x698A #x698B #x698C #x698E #x698F #x6990 #x6991 #x6992 #x6993 #x6996 #x6997 #x6999 #x699A #x699D #x699E #x699F #x69A0 #x69A1 #x69A2 #x69A3 #x69A4 #x69A5 #x69A6 #x69A9 #x69AA #x69AC #x69AE #x69AF #x69B0 #x69B2 #x69B3 #x69B5 #x69B6 #x69B8 #x69B9 #x69BA #x69BC #x69BD #x69BE #x69BF #x69C0 #x69C2 #x69C3 #x69C4 #x69C5 #x69C6 #x69C7 #x69C8 #x69C9 #x69CB #x69CD #x69CF #x69D1 #x69D2 #x69D3 #x69D5 #x69D6 #x69D7 #x69D8 #x69D9 #x69DA #x69DC #x69DD #x69DE #x69E1 #x69E2 #x69E3 #x69E4 #x69E5 #x69E6 #x69E7 #x69E8 #x69E9 #x69EA #x69EB #x69EC #x69EE #x69EF #x69F0 #x69F1 #x69F3 #x69F4 #x69F5 #x69F6 #x69F7 #x69F8 #x69F9 #x69FA #x69FB #x69FC #x69FE #x6A00 #x6A01 #x6A02 #x6A03 #x6A04 #x6A05 #x6A06 #x6A07 #x6A08 #x6A09 #x6A0B #x6A0C #x6A0D #x6A0E #x6A0F #x6A10 #x6A11 #x6A12 #x6A13 #x6A14 #x6A15 #x6A16 #x6A19 #x6A1A #x6A1B #x6A1C #x6A1D #x6A1E #x6A20 #x6A22 #x6A23 #x6A24 #x6A25 #x6A26 #x6A27 #x6A29 #x6A2B #x6A2C #x6A2D #x6A2E #x6A30 #x6A32 #x6A33 #x6A34 #x6A36 #x6A37 #x6A38 #x6A39 #x6A3A #x6A3B #x6A3C #x6A3F #x6A40 #x6A41 #x6A42 #x6A43 #x6A45 #x6A46 #x6A48 #x6A49 #x6A4A #x6A4B #x6A4C #x6A4D #x6A4E #x6A4F #x6A51 #x6A52 #x6A53 #x6A54 #x6A55 #x6A56 #x6A57 #x6A5A #x6A5C #x6A5D #x6A5E #x6A5F #x6A60 #x6A62 #x6A63 #x6A64 #x6A66 #x6A67 #x6A68 #x6A69 #x6A6A #x6A6B #x6A6C #x6A6D #x6A6E #x6A6F #x6A70 #x6A72 #x6A73 #x6A74 #x6A75 #x6A76 #x6A77 #x6A78 #x6A7A #x6A7B #x6A7D #x6A7E #x6A7F #x6A81 #x6A82 #x6A83 #x6A85 #x6A86 #x6A87 #x6A88 #x6A89 #x6A8A #x6A8B #x6A8C #x6A8D #x6A8F #x6A92 #x6A93 #x6A94 #x6A95 #x6A96 #x6A98 #x6A99 #x6A9A #x6A9B #x6A9C #x6A9D #x6A9E #x6A9F #x6AA1 #x6AA2 #x6AA3 #x6AA4 #x6AA5 #x6AA6 #x6AA7 #x6AA8 #x6AAA #x6AAD #x6AAE #x6AAF #x6AB0 #x6AB1 #x6AB2 #x6AB3 #x6AB4 #x6AB5 #x6AB6 #x6AB7 #x6AB8 #x6AB9 #x6ABA #x6ABB #x6ABC #x6ABD #x6ABE #x6ABF #x6AC0 #x6AC1 #x6AC2 #x6AC3 #x6AC4 #x6AC5 #x6AC6 #x6AC7 #x6AC8 #x6AC9 #x6ACA #x6ACB #x6ACC #x6ACD #x6ACE #x6ACF #x6AD0 #x6AD1 #x6AD2 #x6AD3 #x6AD4 #x6AD5 #x6AD6 #x6AD7 #x6AD8 #x6AD9 #x6ADA #x6ADB #x6ADC #x6ADD #x6ADE #x6ADF #x6AE0 #x6AE1 #x6AE2 #x6AE3 #x6AE4 #x6AE5 #x6AE6 #x6AE7 #x6AE8 #x6AE9 #x6AEA #x6AEB #x6AEC #x6AED #x6AEE #x6AEF #x6AF0 #x6AF1 #x6AF2 #x6AF3 #x6AF4 #x6AF5 #x6AF6 #x6AF7 #x6AF8 #x6AF9 #x6AFA #x6AFB #x6AFC #x6AFD #x6AFE #x6AFF #x6B00 #x6B01 #x6B02 #x6B03 #x6B04 #x6B05 #x6B06 #x6B07 #x6B08 #x6B09 #x6B0A #x6B0B #x6B0C #x6B0D #x6B0E #x6B0F #x6B10 #x6B11 #x6B12 #x6B13 #x6B14 #x6B15 #x6B16 #x6B17 #x6B18 #x6B19 #x6B1A #x6B1B #x6B1C #x6B1D #x6B1E #x6B1F #x6B25 #x6B26 #x6B28 #x6B29 #x6B2A #x6B2B #x6B2C #x6B2D #x6B2E #x6B2F #x6B30 #x6B31 #x6B33 #x6B34 #x6B35 #x6B36 #x6B38 #x6B3B #x6B3C #x6B3D #x6B3F #x6B40 #x6B41 #x6B42 #x6B44 #x6B45 #x6B48 #x6B4A #x6B4B #x6B4D #x6B4E #x6B4F #x6B50 #x6B51 #x6B52 #x6B53 #x6B54 #x6B55 #x6B56 #x6B57 #x6B58 #x6B5A #x6B5B #x6B5C #x6B5D #x6B5E #x6B5F #x6B60 #x6B61 #x6B68 #x6B69 #x6B6B #x6B6C #x6B6D #x6B6E #x6B6F #x6B70 #x6B71 #x6B72 #x6B73 #x6B74 #x6B75 #x6B76 #x6B77 #x6B78 #x6B7A #x6B7D #x6B7E #x6B7F #x6B80 #x6B85 #x6B88 #x6B8C #x6B8E #x6B8F #x6B90 #x6B91 #x6B94 #x6B95 #x6B97 #x6B98 #x6B99 #x6B9C #x6B9D #x6B9E #x6B9F #x6BA0 #x6BA2 #x6BA3 #x6BA4 #x6BA5 #x6BA6 #x6BA7 #x6BA8 #x6BA9 #x6BAB #x6BAC #x6BAD #x6BAE #x6BAF #x6BB0 #x6BB1 #x6BB2 #x6BB6 #x6BB8 #x6BB9 #x6BBA #x6BBB #x6BBC #x6BBD #x6BBE #x6BC0 #x6BC3 #x6BC4 #x6BC6 #x6BC7 #x6BC8 #x6BC9 #x6BCA #x6BCC #x6BCE #x6BD0 #x6BD1 #x6BD8 #x6BDA #x6BDC #x6BDD #x6BDE #x6BDF #x6BE0 #x6BE2 #x6BE3 #x6BE4 #x6BE5 #x6BE6 #x6BE7 #x6BE8 #x6BE9 #x6BEC #x6BED #x6BEE #x6BF0 #x6BF1 #x6BF2 #x6BF4 #x6BF6 #x6BF7 #x6BF8 #x6BFA #x6BFB #x6BFC #x6BFE #x6BFF #x6C00 #x6C01 #x6C02 #x6C03 #x6C04 #x6C08 #x6C09 #x6C0A #x6C0B #x6C0C #x6C0E #x6C12 #x6C17 #x6C1C #x6C1D #x6C1E #x6C20 #x6C23 #x6C25 #x6C2B #x6C2C #x6C2D #x6C31 #x6C33 #x6C36 #x6C37 #x6C39 #x6C3A #x6C3B #x6C3C #x6C3E #x6C3F #x6C43 #x6C44 #x6C45 #x6C48 #x6C4B #x6C4C #x6C4D #x6C4E #x6C4F #x6C51 #x6C52 #x6C53 #x6C56 #x6C58 #x6C59 #x6C5A #x6C62 #x6C63 #x6C65 #x6C66 #x6C67 #x6C6B #x6C6C #x6C6D #x6C6E #x6C6F #x6C71 #x6C73 #x6C75 #x6C77 #x6C78 #x6C7A #x6C7B #x6C7C #x6C7F #x6C80 #x6C84 #x6C87 #x6C8A #x6C8B #x6C8D #x6C8E #x6C91 #x6C92 #x6C95 #x6C96 #x6C97 #x6C98 #x6C9A #x6C9C #x6C9D #x6C9E #x6CA0 #x6CA2 #x6CA8 #x6CAC #x6CAF #x6CB0 #x6CB4 #x6CB5 #x6CB6 #x6CB7 #x6CBA #x6CC0 #x6CC1 #x6CC2 #x6CC3 #x6CC6 #x6CC7 #x6CC8 #x6CCB #x6CCD #x6CCE #x6CCF #x6CD1 #x6CD2 #x6CD8 #x6CD9 #x6CDA #x6CDC #x6CDD #x6CDF #x6CE4 #x6CE6 #x6CE7 #x6CE9 #x6CEC #x6CED #x6CF2 #x6CF4 #x6CF9 #x6CFF #x6D00 #x6D02 #x6D03 #x6D05 #x6D06 #x6D08 #x6D09 #x6D0A #x6D0D #x6D0F #x6D10 #x6D11 #x6D13 #x6D14 #x6D15 #x6D16 #x6D18 #x6D1C #x6D1D #x6D1F #x6D20 #x6D21 #x6D22 #x6D23 #x6D24 #x6D26 #x6D28 #x6D29 #x6D2C #x6D2D #x6D2F #x6D30 #x6D34 #x6D36 #x6D37 #x6D38 #x6D3A #x6D3F #x6D40 #x6D42 #x6D44 #x6D49 #x6D4C #x6D50 #x6D55 #x6D56 #x6D57 #x6D58 #x6D5B #x6D5D #x6D5F #x6D61 #x6D62 #x6D64 #x6D65 #x6D67 #x6D68 #x6D6B #x6D6C #x6D6D #x6D70 #x6D71 #x6D72 #x6D73 #x6D75 #x6D76 #x6D79 #x6D7A #x6D7B #x6D7D #x6D7E #x6D7F #x6D80 #x6D81 #x6D83 #x6D84 #x6D86 #x6D87 #x6D8A #x6D8B #x6D8D #x6D8F #x6D90 #x6D92 #x6D96 #x6D97 #x6D98 #x6D99 #x6D9A #x6D9C #x6DA2 #x6DA5 #x6DAC #x6DAD #x6DB0 #x6DB1 #x6DB3 #x6DB4 #x6DB6 #x6DB7 #x6DB9 #x6DBA #x6DBB #x6DBC #x6DBD #x6DBE #x6DC1 #x6DC2 #x6DC3 #x6DC8 #x6DC9 #x6DCA #x6DCD #x6DCE #x6DCF #x6DD0 #x6DD2 #x6DD3 #x6DD4 #x6DD5 #x6DD7 #x6DDA #x6DDB #x6DDC #x6DDF #x6DE2 #x6DE3 #x6DE5 #x6DE7 #x6DE8 #x6DE9 #x6DEA #x6DED #x6DEF #x6DF0 #x6DF2 #x6DF4 #x6DF5 #x6DF6 #x6DF8 #x6DFA #x6DFD #x6DFE #x6DFF #x6E00 #x6E01 #x6E02 #x6E03 #x6E04 #x6E06 #x6E07 #x6E08 #x6E09 #x6E0B #x6E0F #x6E12 #x6E13 #x6E15 #x6E18 #x6E19 #x6E1B #x6E1C #x6E1E #x6E1F #x6E22 #x6E26 #x6E27 #x6E28 #x6E2A #x6E2C #x6E2E #x6E30 #x6E31 #x6E33 #x6E35 #x6E36 #x6E37 #x6E39 #x6E3B #x6E3C #x6E3D #x6E3E #x6E3F #x6E40 #x6E41 #x6E42 #x6E45 #x6E46 #x6E47 #x6E48 #x6E49 #x6E4A #x6E4B #x6E4C #x6E4F #x6E50 #x6E51 #x6E52 #x6E55 #x6E57 #x6E59 #x6E5A #x6E5C #x6E5D #x6E5E #x6E60 #x6E61 #x6E62 #x6E63 #x6E64 #x6E65 #x6E66 #x6E67 #x6E68 #x6E69 #x6E6A #x6E6C #x6E6D #x6E6F #x6E70 #x6E71 #x6E72 #x6E73 #x6E74 #x6E75 #x6E76 #x6E77 #x6E78 #x6E79 #x6E7A #x6E7B #x6E7C #x6E7D #x6E80 #x6E81 #x6E82 #x6E84 #x6E87 #x6E88 #x6E8A #x6E8B #x6E8C #x6E8D #x6E8E #x6E91 #x6E92 #x6E93 #x6E94 #x6E95 #x6E96 #x6E97 #x6E99 #x6E9A #x6E9B #x6E9D #x6E9E #x6EA0 #x6EA1 #x6EA3 #x6EA4 #x6EA6 #x6EA8 #x6EA9 #x6EAB #x6EAC #x6EAD #x6EAE #x6EB0 #x6EB3 #x6EB5 #x6EB8 #x6EB9 #x6EBC #x6EBE #x6EBF #x6EC0 #x6EC3 #x6EC4 #x6EC5 #x6EC6 #x6EC8 #x6EC9 #x6ECA #x6ECC #x6ECD #x6ECE #x6ED0 #x6ED2 #x6ED6 #x6ED8 #x6ED9 #x6EDB #x6EDC #x6EDD #x6EE3 #x6EE7 #x6EEA #x6EEB #x6EEC #x6EED #x6EEE #x6EEF #x6EF0 #x6EF1 #x6EF2 #x6EF3 #x6EF5 #x6EF6 #x6EF7 #x6EF8 #x6EFA #x6EFB #x6EFC #x6EFD #x6EFE #x6EFF #x6F00 #x6F01 #x6F03 #x6F04 #x6F05 #x6F07 #x6F08 #x6F0A #x6F0B #x6F0C #x6F0D #x6F0E #x6F10 #x6F11 #x6F12 #x6F16 #x6F17 #x6F18 #x6F19 #x6F1A #x6F1B #x6F1C #x6F1D #x6F1E #x6F1F #x6F21 #x6F22 #x6F23 #x6F25 #x6F26 #x6F27 #x6F28 #x6F2C #x6F2E #x6F30 #x6F32 #x6F34 #x6F35 #x6F37 #x6F38 #x6F39 #x6F3A #x6F3B #x6F3C #x6F3D #x6F3F #x6F40 #x6F41 #x6F42 #x6F43 #x6F44 #x6F45 #x6F48 #x6F49 #x6F4A #x6F4C #x6F4E #x6F4F #x6F50 #x6F51 #x6F52 #x6F53 #x6F54 #x6F55 #x6F56 #x6F57 #x6F59 #x6F5A #x6F5B #x6F5D #x6F5F #x6F60 #x6F61 #x6F63 #x6F64 #x6F65 #x6F67 #x6F68 #x6F69 #x6F6A #x6F6B #x6F6C #x6F6F #x6F70 #x6F71 #x6F73 #x6F75 #x6F76 #x6F77 #x6F79 #x6F7B #x6F7D #x6F7E #x6F7F #x6F80 #x6F81 #x6F82 #x6F83 #x6F85 #x6F86 #x6F87 #x6F8A #x6F8B #x6F8F #x6F90 #x6F91 #x6F92 #x6F93 #x6F94 #x6F95 #x6F96 #x6F97 #x6F98 #x6F99 #x6F9A #x6F9B #x6F9D #x6F9E #x6F9F #x6FA0 #x6FA2 #x6FA3 #x6FA4 #x6FA5 #x6FA6 #x6FA8 #x6FA9 #x6FAA #x6FAB #x6FAC #x6FAD #x6FAE #x6FAF #x6FB0 #x6FB1 #x6FB2 #x6FB4 #x6FB5 #x6FB7 #x6FB8 #x6FBA #x6FBB #x6FBC #x6FBD #x6FBE #x6FBF #x6FC1 #x6FC3 #x6FC4 #x6FC5 #x6FC6 #x6FC7 #x6FC8 #x6FCA #x6FCB #x6FCC #x6FCD #x6FCE #x6FCF #x6FD0 #x6FD3 #x6FD4 #x6FD5 #x6FD6 #x6FD7 #x6FD8 #x6FD9 #x6FDA #x6FDB #x6FDC #x6FDD #x6FDF #x6FE2 #x6FE3 #x6FE4 #x6FE5 #x6FE6 #x6FE7 #x6FE8 #x6FE9 #x6FEA #x6FEB #x6FEC #x6FED #x6FF0 #x6FF1 #x6FF2 #x6FF3 #x6FF4 #x6FF5 #x6FF6 #x6FF7 #x6FF8 #x6FF9 #x6FFA #x6FFB #x6FFC #x6FFD #x6FFE #x6FFF #x7000 #x7001 #x7002 #x7003 #x7004 #x7005 #x7006 #x7007 #x7008 #x7009 #x700A #x700B #x700C #x700D #x700E #x700F #x7010 #x7012 #x7013 #x7014 #x7015 #x7016 #x7017 #x7018 #x7019 #x701C #x701D #x701E #x701F #x7020 #x7021 #x7022 #x7024 #x7025 #x7026 #x7027 #x7028 #x7029 #x702A #x702B #x702C #x702D #x702E #x702F #x7030 #x7031 #x7032 #x7033 #x7034 #x7036 #x7037 #x7038 #x703A #x703B #x703C #x703D #x703E #x703F #x7040 #x7041 #x7042 #x7043 #x7044 #x7045 #x7046 #x7047 #x7048 #x7049 #x704A #x704B #x704D #x704E #x7050 #x7051 #x7052 #x7053 #x7054 #x7055 #x7056 #x7057 #x7058 #x7059 #x705A #x705B #x705C #x705D #x705F #x7060 #x7061 #x7062 #x7063 #x7064 #x7065 #x7066 #x7067 #x7068 #x7069 #x706A #x706E #x7071 #x7072 #x7073 #x7074 #x7077 #x7079 #x707A #x707B #x707D #x7081 #x7082 #x7083 #x7084 #x7086 #x7087 #x7088 #x708B #x708C #x708D #x708F #x7090 #x7091 #x7093 #x7097 #x7098 #x709A #x709B #x709E #x709F #x70A0 #x70A1 #x70A2 #x70A3 #x70A4 #x70A5 #x70A6 #x70A7 #x70A8 #x70A9 #x70AA #x70B0 #x70B2 #x70B4 #x70B5 #x70B6 #x70BA #x70BE #x70BF #x70C4 #x70C5 #x70C6 #x70C7 #x70C9 #x70CB #x70CC #x70CD #x70CE #x70CF #x70D0 #x70D1 #x70D2 #x70D3 #x70D4 #x70D5 #x70D6 #x70D7 #x70DA #x70DC #x70DD #x70DE #x70E0 #x70E1 #x70E2 #x70E3 #x70E5 #x70EA #x70EE #x70F0 #x70F1 #x70F2 #x70F3 #x70F4 #x70F5 #x70F6 #x70F8 #x70FA #x70FB #x70FC #x70FE #x70FF #x7100 #x7101 #x7102 #x7103 #x7104 #x7105 #x7106 #x7107 #x7108 #x710B #x710C #x710D #x710E #x710F #x7111 #x7112 #x7114 #x7117 #x711B #x711C #x711D #x711E #x711F #x7120 #x7121 #x7122 #x7123 #x7124 #x7125 #x7127 #x7128 #x7129 #x712A #x712B #x712C #x712D #x712E #x7132 #x7133 #x7134 #x7135 #x7137 #x7138 #x7139 #x713A #x713B #x713C #x713D #x713E #x713F #x7140 #x7141 #x7142 #x7143 #x7144 #x7146 #x7147 #x7148 #x7149 #x714B #x714D #x714F #x7150 #x7151 #x7152 #x7153 #x7154 #x7155 #x7156 #x7157 #x7158 #x7159 #x715A #x715B #x715D #x715F #x7160 #x7161 #x7162 #x7163 #x7165 #x7169 #x716A #x716B #x716C #x716D #x716F #x7170 #x7171 #x7174 #x7175 #x7176 #x7177 #x7179 #x717B #x717C #x717E #x717F #x7180 #x7181 #x7182 #x7183 #x7185 #x7186 #x7187 #x7188 #x7189 #x718B #x718C #x718D #x718E #x7190 #x7191 #x7192 #x7193 #x7195 #x7196 #x7197 #x719A #x719B #x719C #x719D #x719E #x71A1 #x71A2 #x71A3 #x71A4 #x71A5 #x71A6 #x71A7 #x71A9 #x71AA #x71AB #x71AD #x71AE #x71AF #x71B0 #x71B1 #x71B2 #x71B4 #x71B6 #x71B7 #x71B8 #x71BA #x71BB #x71BC #x71BD #x71BE #x71BF #x71C0 #x71C1 #x71C2 #x71C4 #x71C5 #x71C6 #x71C7 #x71C8 #x71C9 #x71CA #x71CB #x71CC #x71CD #x71CF #x71D0 #x71D1 #x71D2 #x71D3 #x71D6 #x71D7 #x71D8 #x71D9 #x71DA #x71DB #x71DC #x71DD #x71DE #x71DF #x71E1 #x71E2 #x71E3 #x71E4 #x71E6 #x71E8 #x71E9 #x71EA #x71EB #x71EC #x71ED #x71EF #x71F0 #x71F1 #x71F2 #x71F3 #x71F4 #x71F5 #x71F6 #x71F7 #x71F8 #x71FA #x71FB #x71FC #x71FD #x71FE #x71FF #x7200 #x7201 #x7202 #x7203 #x7204 #x7205 #x7207 #x7208 #x7209 #x720A #x720B #x720C #x720D #x720E #x720F #x7210 #x7211 #x7212 #x7213 #x7214 #x7215 #x7216 #x7217 #x7218 #x7219 #x721A #x721B #x721C #x721E #x721F #x7220 #x7221 #x7222 #x7223 #x7224 #x7225 #x7226 #x7227 #x7229 #x722B #x722D #x722E #x722F #x7232 #x7233 #x7234 #x723A #x723C #x723E #x7240 #x7241 #x7242 #x7243 #x7244 #x7245 #x7246 #x7249 #x724A #x724B #x724E #x724F #x7250 #x7251 #x7253 #x7254 #x7255 #x7257 #x7258 #x725A #x725C #x725E #x7260 #x7263 #x7264 #x7265 #x7268 #x726A #x726B #x726C #x726D #x7270 #x7271 #x7273 #x7274 #x7276 #x7277 #x7278 #x727B #x727C #x727D #x7282 #x7283 #x7285 #x7286 #x7287 #x7288 #x7289 #x728C #x728E #x7290 #x7291 #x7293 #x7294 #x7295 #x7296 #x7297 #x7298 #x7299 #x729A #x729B #x729C #x729D #x729E #x72A0 #x72A1 #x72A2 #x72A3 #x72A4 #x72A5 #x72A6 #x72A7 #x72A8 #x72A9 #x72AA #x72AB #x72AE #x72B1 #x72B2 #x72B3 #x72B5 #x72BA #x72BB #x72BC #x72BD #x72BE #x72BF #x72C0 #x72C5 #x72C6 #x72C7 #x72C9 #x72CA #x72CB #x72CC #x72CF #x72D1 #x72D3 #x72D4 #x72D5 #x72D6 #x72D8 #x72DA #x72DB #x72DC #x72DD #x72DF #x72E2 #x72E3 #x72E4 #x72E5 #x72E6 #x72E7 #x72EA #x72EB #x72F5 #x72F6 #x72F9 #x72FD #x72FE #x72FF #x7300 #x7302 #x7304 #x7305 #x7306 #x7307 #x7308 #x7309 #x730B #x730C #x730D #x730F #x7310 #x7311 #x7312 #x7314 #x7318 #x7319 #x731A #x731F #x7320 #x7323 #x7324 #x7326 #x7327 #x7328 #x732D #x732F #x7330 #x7332 #x7333 #x7335 #x7336 #x733A #x733B #x733C #x733D #x7340 #x7341 #x7342 #x7343 #x7344 #x7345 #x7346 #x7347 #x7348 #x7349 #x734A #x734B #x734C #x734E #x734F #x7351 #x7353 #x7354 #x7355 #x7356 #x7358 #x7359 #x735A #x735B #x735C #x735D #x735E #x735F #x7361 #x7362 #x7363 #x7364 #x7365 #x7366 #x7367 #x7368 #x7369 #x736A #x736B #x736E #x7370 #x7371 #x7372 #x7373 #x7374 #x7375 #x7376 #x7377 #x7378 #x7379 #x737A #x737B #x737C #x737D #x737F #x7380 #x7381 #x7382 #x7383 #x7385 #x7386 #x7388 #x738A #x738C #x738D #x738F #x7390 #x7392 #x7393 #x7394 #x7395 #x7397 #x7398 #x7399 #x739A #x739C #x739D #x739E #x73A0 #x73A1 #x73A3 #x73A4 #x73A5 #x73A6 #x73A7 #x73A8 #x73AA #x73AC #x73AD #x73B1 #x73B4 #x73B5 #x73B6 #x73B8 #x73B9 #x73BC #x73BD #x73BE #x73BF #x73C1 #x73C3 #x73C4 #x73C5 #x73C6 #x73C7 #x73CB #x73CC #x73CE #x73D2 #x73D3 #x73D4 #x73D5 #x73D6 #x73D7 #x73D8 #x73DA #x73DB #x73DC #x73DD #x73DF #x73E1 #x73E2 #x73E3 #x73E4 #x73E6 #x73E8 #x73EA #x73EB #x73EC #x73EE #x73EF #x73F0 #x73F1 #x73F3 #x73F4 #x73F5 #x73F6 #x73F7 #x73F8 #x73F9 #x73FA #x73FB #x73FC #x73FD #x73FE #x73FF #x7400 #x7401 #x7402 #x7404 #x7407 #x7408 #x740B #x740C #x740D #x740E #x7411 #x7412 #x7413 #x7414 #x7415 #x7416 #x7417 #x7418 #x7419 #x741C #x741D #x741E #x741F #x7420 #x7421 #x7423 #x7424 #x7427 #x7429 #x742B #x742D #x742F #x7431 #x7432 #x7437 #x7438 #x7439 #x743A #x743B #x743D #x743E #x743F #x7440 #x7442 #x7443 #x7444 #x7445 #x7446 #x7447 #x7448 #x7449 #x744A #x744B #x744C #x744D #x744E #x744F #x7450 #x7451 #x7452 #x7453 #x7454 #x7456 #x7458 #x745D #x7460 #x7461 #x7462 #x7463 #x7464 #x7465 #x7466 #x7467 #x7468 #x7469 #x746A #x746B #x746C #x746E #x746F #x7471 #x7472 #x7473 #x7474 #x7475 #x7478 #x7479 #x747A #x747B #x747C #x747D #x747F #x7482 #x7484 #x7485 #x7486 #x7488 #x7489 #x748A #x748C #x748D #x748F #x7491 #x7492 #x7493 #x7494 #x7495 #x7496 #x7497 #x7498 #x7499 #x749A #x749B #x749D #x749F #x74A0 #x74A1 #x74A2 #x74A3 #x74A4 #x74A5 #x74A6 #x74AA #x74AB #x74AC #x74AD #x74AE #x74AF #x74B0 #x74B1 #x74B2 #x74B3 #x74B4 #x74B5 #x74B6 #x74B7 #x74B8 #x74B9 #x74BB #x74BC #x74BD #x74BE #x74BF #x74C0 #x74C1 #x74C2 #x74C3 #x74C4 #x74C5 #x74C6 #x74C7 #x74C8 #x74C9 #x74CA #x74CB #x74CC #x74CD #x74CE #x74CF #x74D0 #x74D1 #x74D3 #x74D4 #x74D5 #x74D6 #x74D7 #x74D8 #x74D9 #x74DA #x74DB #x74DD #x74DF #x74E1 #x74E5 #x74E7 #x74E8 #x74E9 #x74EA #x74EB #x74EC #x74ED #x74F0 #x74F1 #x74F2 #x74F3 #x74F5 #x74F8 #x74F9 #x74FA #x74FB #x74FC #x74FD #x74FE #x7500 #x7501 #x7502 #x7503 #x7505 #x7506 #x7507 #x7508 #x7509 #x750A #x750B #x750C #x750E #x7510 #x7512 #x7514 #x7515 #x7516 #x7517 #x751B #x751D #x751E #x7520 #x7521 #x7522 #x7523 #x7524 #x7526 #x7527 #x752A #x752E #x7534 #x7536 #x7539 #x753C #x753D #x753F #x7541 #x7542 #x7543 #x7544 #x7546 #x7547 #x7549 #x754A #x754D #x7550 #x7551 #x7552 #x7553 #x7555 #x7556 #x7557 #x7558 #x755D #x755E #x755F #x7560 #x7561 #x7562 #x7563 #x7564 #x7567 #x7568 #x7569 #x756B #x756C #x756D #x756E #x756F #x7570 #x7571 #x7573 #x7575 #x7576 #x7577 #x757A #x757B #x757C #x757D #x757E #x7580 #x7581 #x7582 #x7584 #x7585 #x7587 #x7588 #x7589 #x758A #x758C #x758D #x758E #x7590 #x7593 #x7595 #x7598 #x759B #x759C #x759E #x75A2 #x75A6 #x75A7 #x75A8 #x75A9 #x75AA #x75AD #x75B6 #x75B7 #x75BA #x75BB #x75BF #x75C0 #x75C1 #x75C6 #x75CB #x75CC #x75CE #x75CF #x75D0 #x75D1 #x75D3 #x75D7 #x75D9 #x75DA #x75DC #x75DD #x75DF #x75E0 #x75E1 #x75E5 #x75E9 #x75EC #x75ED #x75EE #x75EF #x75F2 #x75F3 #x75F5 #x75F6 #x75F7 #x75F8 #x75FA #x75FB #x75FD #x75FE #x7602 #x7604 #x7606 #x7607 #x7608 #x7609 #x760B #x760D #x760E #x760F #x7611 #x7612 #x7613 #x7614 #x7616 #x761A #x761C #x761D #x761E #x7621 #x7623 #x7627 #x7628 #x762C #x762E #x762F #x7631 #x7632 #x7636 #x7637 #x7639 #x763A #x763B #x763D #x7641 #x7642 #x7644 #x7645 #x7646 #x7647 #x7648 #x7649 #x764A #x764B #x764E #x764F #x7650 #x7651 #x7652 #x7653 #x7655 #x7657 #x7658 #x7659 #x765A #x765B #x765D #x765F #x7660 #x7661 #x7662 #x7664 #x7665 #x7666 #x7667 #x7668 #x7669 #x766A #x766C #x766D #x766E #x7670 #x7671 #x7672 #x7673 #x7674 #x7675 #x7676 #x7677 #x7679 #x767A #x767C #x767F #x7680 #x7681 #x7683 #x7685 #x7689 #x768A #x768C #x768D #x768F #x7690 #x7692 #x7694 #x7695 #x7697 #x7698 #x769A #x769B #x769C #x769D #x769E #x769F #x76A0 #x76A1 #x76A2 #x76A3 #x76A5 #x76A6 #x76A7 #x76A8 #x76A9 #x76AA #x76AB #x76AC #x76AD #x76AF #x76B0 #x76B3 #x76B5 #x76B6 #x76B7 #x76B8 #x76B9 #x76BA #x76BB #x76BC #x76BD #x76BE #x76C0 #x76C1 #x76C3 #x76C4 #x76C7 #x76C9 #x76CB #x76CC #x76D3 #x76D5 #x76D9 #x76DA #x76DC #x76DD #x76DE #x76E0 #x76E1 #x76E2 #x76E3 #x76E4 #x76E6 #x76E7 #x76E8 #x76E9 #x76EA #x76EB #x76EC #x76ED #x76F0 #x76F3 #x76F5 #x76F6 #x76F7 #x76FA #x76FB #x76FD #x76FF #x7700 #x7702 #x7703 #x7705 #x7706 #x770A #x770C #x770E #x770F #x7710 #x7711 #x7712 #x7713 #x7714 #x7715 #x7716 #x7717 #x7718 #x771B #x771C #x771D #x771E #x7721 #x7723 #x7724 #x7725 #x7727 #x772A #x772B #x772C #x772E #x7730 #x7731 #x7732 #x7733 #x7734 #x7739 #x773B #x773D #x773E #x773F #x7742 #x7744 #x7745 #x7746 #x7748 #x7749 #x774A #x774B #x774C #x774D #x774E #x774F #x7752 #x7753 #x7754 #x7755 #x7756 #x7757 #x7758 #x7759 #x775C #x775D #x775E #x775F #x7760 #x7764 #x7767 #x7769 #x776A #x776D #x776E #x776F #x7770 #x7771 #x7772 #x7773 #x7774 #x7775 #x7776 #x7777 #x7778 #x777A #x777B #x777C #x7781 #x7782 #x7783 #x7786 #x7787 #x7788 #x7789 #x778A #x778B #x778F #x7790 #x7793 #x7794 #x7795 #x7796 #x7797 #x7798 #x7799 #x779A #x779B #x779C #x779D #x779E #x77A1 #x77A3 #x77A4 #x77A6 #x77A8 #x77AB #x77AD #x77AE #x77AF #x77B1 #x77B2 #x77B4 #x77B6 #x77B7 #x77B8 #x77B9 #x77BA #x77BC #x77BE #x77C0 #x77C1 #x77C2 #x77C3 #x77C4 #x77C5 #x77C6 #x77C7 #x77C8 #x77C9 #x77CA #x77CB #x77CC #x77CE #x77CF #x77D0 #x77D1 #x77D2 #x77D3 #x77D4 #x77D5 #x77D6 #x77D8 #x77D9 #x77DA #x77DD #x77DE #x77DF #x77E0 #x77E1 #x77E4 #x77E6 #x77E8 #x77EA #x77EF #x77F0 #x77F1 #x77F2 #x77F4 #x77F5 #x77F7 #x77F9 #x77FA #x77FB #x77FC #x7803 #x7804 #x7805 #x7806 #x7807 #x7808 #x780A #x780B #x780E #x780F #x7810 #x7813 #x7815 #x7819 #x781B #x781E #x7820 #x7821 #x7822 #x7824 #x7828 #x782A #x782B #x782E #x782F #x7831 #x7832 #x7833 #x7835 #x7836 #x783D #x783F #x7841 #x7842 #x7843 #x7844 #x7846 #x7848 #x7849 #x784A #x784B #x784D #x784F #x7851 #x7853 #x7854 #x7858 #x7859 #x785A #x785B #x785C #x785E #x785F #x7860 #x7861 #x7862 #x7863 #x7864 #x7865 #x7866 #x7867 #x7868 #x7869 #x786F #x7870 #x7871 #x7872 #x7873 #x7874 #x7875 #x7876 #x7878 #x7879 #x787A #x787B #x787D #x787E #x787F #x7880 #x7881 #x7882 #x7883 #x7884 #x7885 #x7886 #x7888 #x788A #x788B #x788F #x7890 #x7892 #x7894 #x7895 #x7896 #x7899 #x789D #x789E #x78A0 #x78A2 #x78A4 #x78A6 #x78A8 #x78A9 #x78AA #x78AB #x78AC #x78AD #x78AE #x78AF #x78B5 #x78B6 #x78B7 #x78B8 #x78BA #x78BB #x78BC #x78BD #x78BF #x78C0 #x78C2 #x78C3 #x78C4 #x78C6 #x78C7 #x78C8 #x78CC #x78CD #x78CE #x78CF #x78D1 #x78D2 #x78D3 #x78D6 #x78D7 #x78D8 #x78DA #x78DB #x78DC #x78DD #x78DE #x78DF #x78E0 #x78E1 #x78E2 #x78E3 #x78E4 #x78E5 #x78E6 #x78E7 #x78E9 #x78EA #x78EB #x78ED #x78EE #x78EF #x78F0 #x78F1 #x78F3 #x78F5 #x78F6 #x78F8 #x78F9 #x78FB #x78FC #x78FD #x78FE #x78FF #x7900 #x7902 #x7903 #x7904 #x7906 #x7907 #x7908 #x7909 #x790A #x790B #x790C #x790D #x790E #x790F #x7910 #x7911 #x7912 #x7914 #x7915 #x7916 #x7917 #x7918 #x7919 #x791A #x791B #x791C #x791D #x791F #x7920 #x7921 #x7922 #x7923 #x7925 #x7926 #x7927 #x7928 #x7929 #x792A #x792B #x792C #x792D #x792E #x792F #x7930 #x7931 #x7932 #x7933 #x7935 #x7936 #x7937 #x7938 #x7939 #x793D #x793F #x7942 #x7943 #x7944 #x7945 #x7947 #x794A #x794B #x794C #x794D #x794E #x794F #x7950 #x7951 #x7952 #x7954 #x7955 #x7958 #x7959 #x7961 #x7963 #x7964 #x7966 #x7969 #x796A #x796B #x796C #x796E #x7970 #x7971 #x7972 #x7973 #x7974 #x7975 #x7976 #x7979 #x797B #x797C #x797D #x797E #x797F #x7982 #x7983 #x7986 #x7987 #x7988 #x7989 #x798B #x798C #x798D #x798E #x7990 #x7991 #x7992 #x7993 #x7994 #x7995 #x7996 #x7997 #x7998 #x7999 #x799B #x799C #x799D #x799E #x799F #x79A0 #x79A1 #x79A2 #x79A3 #x79A4 #x79A5 #x79A6 #x79A8 #x79A9 #x79AA #x79AB #x79AC #x79AD #x79AE #x79AF #x79B0 #x79B1 #x79B2 #x79B4 #x79B5 #x79B6 #x79B7 #x79B8 #x79BC #x79BF #x79C2 #x79C4 #x79C5 #x79C7 #x79C8 #x79CA #x79CC #x79CE #x79CF #x79D0 #x79D3 #x79D4 #x79D6 #x79D7 #x79D9 #x79DA #x79DB #x79DC #x79DD #x79DE #x79E0 #x79E1 #x79E2 #x79E5 #x79E8 #x79EA #x79EC #x79EE #x79F1 #x79F2 #x79F3 #x79F4 #x79F5 #x79F6 #x79F7 #x79F9 #x79FA #x79FC #x79FE #x79FF #x7A01 #x7A04 #x7A05 #x7A07 #x7A08 #x7A09 #x7A0A #x7A0C #x7A0F #x7A10 #x7A11 #x7A12 #x7A13 #x7A15 #x7A16 #x7A18 #x7A19 #x7A1B #x7A1C #x7A1D #x7A1F #x7A21 #x7A22 #x7A24 #x7A25 #x7A26 #x7A27 #x7A28 #x7A29 #x7A2A #x7A2B #x7A2C #x7A2D #x7A2E #x7A2F #x7A30 #x7A31 #x7A32 #x7A34 #x7A35 #x7A36 #x7A38 #x7A3A #x7A3E #x7A40 #x7A41 #x7A42 #x7A43 #x7A44 #x7A45 #x7A47 #x7A48 #x7A49 #x7A4A #x7A4B #x7A4C #x7A4D #x7A4E #x7A4F #x7A50 #x7A52 #x7A53 #x7A54 #x7A55 #x7A56 #x7A58 #x7A59 #x7A5A #x7A5B #x7A5C #x7A5D #x7A5E #x7A5F #x7A60 #x7A61 #x7A62 #x7A63 #x7A64 #x7A65 #x7A66 #x7A67 #x7A68 #x7A69 #x7A6A #x7A6B #x7A6C #x7A6D #x7A6E #x7A6F #x7A71 #x7A72 #x7A73 #x7A75 #x7A7B #x7A7C #x7A7D #x7A7E #x7A82 #x7A85 #x7A87 #x7A89 #x7A8A #x7A8B #x7A8C #x7A8E #x7A8F #x7A90 #x7A93 #x7A94 #x7A99 #x7A9A #x7A9B #x7A9E #x7AA1 #x7AA2 #x7AA3 #x7AA4 #x7AA7 #x7AA9 #x7AAA #x7AAB #x7AAE #x7AAF #x7AB0 #x7AB1 #x7AB2 #x7AB4 #x7AB5 #x7AB6 #x7AB7 #x7AB8 #x7AB9 #x7ABA #x7ABB #x7ABC #x7ABD #x7ABE #x7AC0 #x7AC1 #x7AC2 #x7AC3 #x7AC4 #x7AC5 #x7AC6 #x7AC7 #x7AC8 #x7AC9 #x7ACA #x7ACC #x7ACD #x7ACE #x7ACF #x7AD0 #x7AD1 #x7AD2 #x7AD3 #x7AD4 #x7AD5 #x7AD7 #x7AD8 #x7ADA #x7ADB #x7ADC #x7ADD #x7AE1 #x7AE2 #x7AE4 #x7AE7 #x7AE8 #x7AE9 #x7AEA #x7AEB #x7AEC #x7AEE #x7AF0 #x7AF1 #x7AF2 #x7AF3 #x7AF4 #x7AF5 #x7AF6 #x7AF7 #x7AF8 #x7AFB #x7AFC #x7AFE #x7B00 #x7B01 #x7B02 #x7B05 #x7B07 #x7B09 #x7B0C #x7B0D #x7B0E #x7B10 #x7B12 #x7B13 #x7B16 #x7B17 #x7B18 #x7B1A #x7B1C #x7B1D #x7B1F #x7B21 #x7B22 #x7B23 #x7B27 #x7B29 #x7B2D #x7B2F #x7B30 #x7B32 #x7B34 #x7B35 #x7B36 #x7B37 #x7B39 #x7B3B #x7B3D #x7B3F #x7B40 #x7B41 #x7B42 #x7B43 #x7B44 #x7B46 #x7B48 #x7B4A #x7B4D #x7B4E #x7B53 #x7B55 #x7B57 #x7B59 #x7B5C #x7B5E #x7B5F #x7B61 #x7B63 #x7B64 #x7B65 #x7B66 #x7B67 #x7B68 #x7B69 #x7B6A #x7B6B #x7B6C #x7B6D #x7B6F #x7B70 #x7B73 #x7B74 #x7B76 #x7B78 #x7B7A #x7B7C #x7B7D #x7B7F #x7B81 #x7B82 #x7B83 #x7B84 #x7B86 #x7B87 #x7B88 #x7B89 #x7B8A #x7B8B #x7B8C #x7B8E #x7B8F #x7B91 #x7B92 #x7B93 #x7B96 #x7B98 #x7B99 #x7B9A #x7B9B #x7B9E #x7B9F #x7BA0 #x7BA3 #x7BA4 #x7BA5 #x7BAE #x7BAF #x7BB0 #x7BB2 #x7BB3 #x7BB5 #x7BB6 #x7BB7 #x7BB9 #x7BBA #x7BBB #x7BBC #x7BBD #x7BBE #x7BBF #x7BC0 #x7BC2 #x7BC3 #x7BC4 #x7BC5 #x7BC8 #x7BC9 #x7BCA #x7BCB #x7BCD #x7BCE #x7BCF #x7BD0 #x7BD2 #x7BD4 #x7BD5 #x7BD6 #x7BD7 #x7BD8 #x7BDB #x7BDC #x7BDE #x7BDF #x7BE0 #x7BE2 #x7BE3 #x7BE4 #x7BE7 #x7BE8 #x7BE9 #x7BEB #x7BEC #x7BED #x7BEF #x7BF0 #x7BF2 #x7BF3 #x7BF4 #x7BF5 #x7BF6 #x7BF8 #x7BF9 #x7BFA #x7BFB #x7BFD #x7BFF #x7C00 #x7C01 #x7C02 #x7C03 #x7C04 #x7C05 #x7C06 #x7C08 #x7C09 #x7C0A #x7C0D #x7C0E #x7C10 #x7C11 #x7C12 #x7C13 #x7C14 #x7C15 #x7C17 #x7C18 #x7C19 #x7C1A #x7C1B #x7C1C #x7C1D #x7C1E #x7C20 #x7C21 #x7C22 #x7C23 #x7C24 #x7C25 #x7C28 #x7C29 #x7C2B #x7C2C #x7C2D #x7C2E #x7C2F #x7C30 #x7C31 #x7C32 #x7C33 #x7C34 #x7C35 #x7C36 #x7C37 #x7C39 #x7C3A #x7C3B #x7C3C #x7C3D #x7C3E #x7C42 #x7C43 #x7C44 #x7C45 #x7C46 #x7C47 #x7C48 #x7C49 #x7C4A #x7C4B #x7C4C #x7C4E #x7C4F #x7C50 #x7C51 #x7C52 #x7C53 #x7C54 #x7C55 #x7C56 #x7C57 #x7C58 #x7C59 #x7C5A #x7C5B #x7C5C #x7C5D #x7C5E #x7C5F #x7C60 #x7C61 #x7C62 #x7C63 #x7C64 #x7C65 #x7C66 #x7C67 #x7C68 #x7C69 #x7C6A #x7C6B #x7C6C #x7C6D #x7C6E #x7C6F #x7C70 #x7C71 #x7C72 #x7C75 #x7C76 #x7C77 #x7C78 #x7C79 #x7C7A #x7C7E #x7C7F #x7C80 #x7C81 #x7C82 #x7C83 #x7C84 #x7C85 #x7C86 #x7C87 #x7C88 #x7C8A #x7C8B #x7C8C #x7C8D #x7C8E #x7C8F #x7C90 #x7C93 #x7C94 #x7C96 #x7C99 #x7C9A #x7C9B #x7CA0 #x7CA1 #x7CA3 #x7CA6 #x7CA7 #x7CA8 #x7CA9 #x7CAB #x7CAC #x7CAD #x7CAF #x7CB0 #x7CB4 #x7CB5 #x7CB6 #x7CB7 #x7CB8 #x7CBA #x7CBB #x7CBF #x7CC0 #x7CC2 #x7CC3 #x7CC4 #x7CC6 #x7CC9 #x7CCB #x7CCE #x7CCF #x7CD0 #x7CD1 #x7CD2 #x7CD3 #x7CD4 #x7CD8 #x7CDA #x7CDB #x7CDD #x7CDE #x7CE1 #x7CE2 #x7CE3 #x7CE4 #x7CE5 #x7CE6 #x7CE7 #x7CE9 #x7CEA #x7CEB #x7CEC #x7CED #x7CEE #x7CF0 #x7CF1 #x7CF2 #x7CF3 #x7CF4 #x7CF5 #x7CF6 #x7CF7 #x7CF9 #x7CFA #x7CFC #x7CFD #x7CFE #x7CFF #x7D00 #x7D01 #x7D02 #x7D03 #x7D04 #x7D05 #x7D06 #x7D07 #x7D08 #x7D09 #x7D0B #x7D0C #x7D0D #x7D0E #x7D0F #x7D10 #x7D11 #x7D12 #x7D13 #x7D14 #x7D15 #x7D16 #x7D17 #x7D18 #x7D19 #x7D1A #x7D1B #x7D1C #x7D1D #x7D1E #x7D1F #x7D21 #x7D23 #x7D24 #x7D25 #x7D26 #x7D28 #x7D29 #x7D2A #x7D2C #x7D2D #x7D2E #x7D30 #x7D31 #x7D32 #x7D33 #x7D34 #x7D35 #x7D36 #x7D37 #x7D38 #x7D39 #x7D3A #x7D3B #x7D3C #x7D3D #x7D3E #x7D3F #x7D40 #x7D41 #x7D42 #x7D43 #x7D44 #x7D45 #x7D46 #x7D47 #x7D48 #x7D49 #x7D4A #x7D4B #x7D4C #x7D4D #x7D4E #x7D4F #x7D50 #x7D51 #x7D52 #x7D53 #x7D54 #x7D55 #x7D56 #x7D57 #x7D58 #x7D59 #x7D5A #x7D5B #x7D5C #x7D5D #x7D5E #x7D5F #x7D60 #x7D61 #x7D62 #x7D63 #x7D64 #x7D65 #x7D66 #x7D67 #x7D68 #x7D69 #x7D6A #x7D6B #x7D6C #x7D6D #x7D6F #x7D70 #x7D71 #x7D72 #x7D73 #x7D74 #x7D75 #x7D76 #x7D78 #x7D79 #x7D7A #x7D7B #x7D7C #x7D7D #x7D7E #x7D7F #x7D80 #x7D81 #x7D82 #x7D83 #x7D84 #x7D85 #x7D86 #x7D87 #x7D88 #x7D89 #x7D8A #x7D8B #x7D8C #x7D8D #x7D8E #x7D8F #x7D90 #x7D91 #x7D92 #x7D93 #x7D94 #x7D95 #x7D96 #x7D97 #x7D98 #x7D99 #x7D9A #x7D9B #x7D9C #x7D9D #x7D9E #x7D9F #x7DA0 #x7DA1 #x7DA2 #x7DA3 #x7DA4 #x7DA5 #x7DA7 #x7DA8 #x7DA9 #x7DAA #x7DAB #x7DAC #x7DAD #x7DAF #x7DB0 #x7DB1 #x7DB2 #x7DB3 #x7DB4 #x7DB5 #x7DB6 #x7DB7 #x7DB8 #x7DB9 #x7DBA #x7DBB #x7DBC #x7DBD #x7DBE #x7DBF #x7DC0 #x7DC1 #x7DC2 #x7DC3 #x7DC4 #x7DC5 #x7DC6 #x7DC7 #x7DC8 #x7DC9 #x7DCA #x7DCB #x7DCC #x7DCD #x7DCE #x7DCF #x7DD0 #x7DD1 #x7DD2 #x7DD3 #x7DD4 #x7DD5 #x7DD6 #x7DD7 #x7DD8 #x7DD9 #x7DDA #x7DDB #x7DDC #x7DDD #x7DDE #x7DDF #x7DE0 #x7DE1 #x7DE2 #x7DE3 #x7DE4 #x7DE5 #x7DE6 #x7DE7 #x7DE8 #x7DE9 #x7DEA #x7DEB #x7DEC #x7DED #x7DEE #x7DEF #x7DF0 #x7DF1 #x7DF2 #x7DF3 #x7DF4 #x7DF5 #x7DF6 #x7DF7 #x7DF8 #x7DF9 #x7DFA #x7DFB #x7DFC #x7DFD #x7DFE #x7DFF #x7E00 #x7E01 #x7E02 #x7E03 #x7E04 #x7E05 #x7E06 #x7E07 #x7E08 #x7E09 #x7E0A #x7E0B #x7E0C #x7E0D #x7E0E #x7E0F #x7E10 #x7E11 #x7E12 #x7E13 #x7E14 #x7E15 #x7E16 #x7E17 #x7E18 #x7E19 #x7E1A #x7E1B #x7E1C #x7E1D #x7E1E #x7E1F #x7E20 #x7E21 #x7E22 #x7E23 #x7E24 #x7E25 #x7E26 #x7E27 #x7E28 #x7E29 #x7E2A #x7E2B #x7E2C #x7E2D #x7E2E #x7E2F #x7E30 #x7E31 #x7E32 #x7E33 #x7E34 #x7E35 #x7E36 #x7E37 #x7E38 #x7E39 #x7E3A #x7E3C #x7E3D #x7E3E #x7E3F #x7E40 #x7E42 #x7E43 #x7E44 #x7E45 #x7E46 #x7E48 #x7E49 #x7E4A #x7E4B #x7E4C #x7E4D #x7E4E #x7E4F #x7E50 #x7E51 #x7E52 #x7E53 #x7E54 #x7E55 #x7E56 #x7E57 #x7E58 #x7E59 #x7E5A #x7E5B #x7E5C #x7E5D #x7E5E #x7E5F #x7E60 #x7E61 #x7E62 #x7E63 #x7E64 #x7E65 #x7E66 #x7E67 #x7E68 #x7E69 #x7E6A #x7E6B #x7E6C #x7E6D #x7E6E #x7E6F #x7E70 #x7E71 #x7E72 #x7E73 #x7E74 #x7E75 #x7E76 #x7E77 #x7E78 #x7E79 #x7E7A #x7E7B #x7E7C #x7E7D #x7E7E #x7E7F #x7E80 #x7E81 #x7E83 #x7E84 #x7E85 #x7E86 #x7E87 #x7E88 #x7E89 #x7E8A #x7E8B #x7E8C #x7E8D #x7E8E #x7E8F #x7E90 #x7E91 #x7E92 #x7E93 #x7E94 #x7E95 #x7E96 #x7E97 #x7E98 #x7E99 #x7E9A #x7E9C #x7E9D #x7E9E #x7EAE #x7EB4 #x7EBB #x7EBC #x7ED6 #x7EE4 #x7EEC #x7EF9 #x7F0A #x7F10 #x7F1E #x7F37 #x7F39 #x7F3B #x7F3C #x7F3D #x7F3E #x7F3F #x7F40 #x7F41 #x7F43 #x7F46 #x7F47 #x7F48 #x7F49 #x7F4A #x7F4B #x7F4C #x7F4D #x7F4E #x7F4F #x7F52 #x7F53 #x7F56 #x7F59 #x7F5B #x7F5C #x7F5D #x7F5E #x7F60 #x7F63 #x7F64 #x7F65 #x7F66 #x7F67 #x7F6B #x7F6C #x7F6D #x7F6F #x7F70 #x7F73 #x7F75 #x7F76 #x7F77 #x7F78 #x7F7A #x7F7B #x7F7C #x7F7D #x7F7F #x7F80 #x7F82 #x7F83 #x7F84 #x7F85 #x7F86 #x7F87 #x7F88 #x7F89 #x7F8B #x7F8D #x7F8F #x7F90 #x7F91 #x7F92 #x7F93 #x7F95 #x7F96 #x7F97 #x7F98 #x7F99 #x7F9B #x7F9C #x7FA0 #x7FA2 #x7FA3 #x7FA5 #x7FA6 #x7FA8 #x7FA9 #x7FAA #x7FAB #x7FAC #x7FAD #x7FAE #x7FB1 #x7FB3 #x7FB4 #x7FB5 #x7FB6 #x7FB7 #x7FBA #x7FBB #x7FBE #x7FC0 #x7FC2 #x7FC3 #x7FC4 #x7FC6 #x7FC7 #x7FC8 #x7FC9 #x7FCB #x7FCD #x7FCF #x7FD0 #x7FD1 #x7FD2 #x7FD3 #x7FD6 #x7FD7 #x7FD9 #x7FDA #x7FDB #x7FDC #x7FDD #x7FDE #x7FE2 #x7FE3 #x7FE4 #x7FE7 #x7FE8 #x7FEA #x7FEB #x7FEC #x7FED #x7FEF #x7FF2 #x7FF4 #x7FF5 #x7FF6 #x7FF7 #x7FF8 #x7FF9 #x7FFA #x7FFD #x7FFE #x7FFF #x8002 #x8007 #x8008 #x8009 #x800A #x800E #x800F #x8011 #x8013 #x801A #x801B #x801D #x801E #x801F #x8021 #x8023 #x8024 #x802B #x802C #x802D #x802E #x802F #x8030 #x8032 #x8034 #x8039 #x803A #x803C #x803E #x8040 #x8041 #x8044 #x8045 #x8047 #x8048 #x8049 #x804E #x804F #x8050 #x8051 #x8053 #x8055 #x8056 #x8057 #x8059 #x805B #x805C #x805D #x805E #x805F #x8060 #x8061 #x8062 #x8063 #x8064 #x8065 #x8066 #x8067 #x8068 #x806B #x806C #x806D #x806E #x806F #x8070 #x8072 #x8073 #x8074 #x8075 #x8076 #x8077 #x8078 #x8079 #x807A #x807B #x807C #x807D #x807E #x8081 #x8082 #x8085 #x8088 #x808A #x808D #x808E #x808F #x8090 #x8091 #x8092 #x8094 #x8095 #x8097 #x8099 #x809E #x80A3 #x80A6 #x80A7 #x80A8 #x80AC #x80B0 #x80B3 #x80B5 #x80B6 #x80B8 #x80B9 #x80BB #x80C5 #x80C7 #x80C8 #x80C9 #x80CA #x80CB #x80CF #x80D0 #x80D1 #x80D2 #x80D3 #x80D4 #x80D5 #x80D8 #x80DF #x80E0 #x80E2 #x80E3 #x80E6 #x80EE #x80F5 #x80F7 #x80F9 #x80FB #x80FE #x80FF #x8100 #x8101 #x8103 #x8104 #x8105 #x8107 #x8108 #x810B #x810C #x8115 #x8117 #x8119 #x811B #x811C #x811D #x811F #x8120 #x8121 #x8122 #x8123 #x8124 #x8125 #x8126 #x8127 #x8128 #x8129 #x812A #x812B #x812D #x812E #x8130 #x8133 #x8134 #x8135 #x8137 #x8139 #x813A #x813B #x813C #x813D #x813F #x8140 #x8141 #x8142 #x8143 #x8144 #x8145 #x8147 #x8149 #x814D #x814E #x814F #x8152 #x8156 #x8157 #x8158 #x815B #x815C #x815D #x815E #x815F #x8161 #x8162 #x8163 #x8164 #x8166 #x8168 #x816A #x816B #x816C #x816F #x8172 #x8173 #x8175 #x8176 #x8177 #x8178 #x8181 #x8183 #x8184 #x8185 #x8186 #x8187 #x8189 #x818B #x818C #x818D #x818E #x8190 #x8192 #x8193 #x8194 #x8195 #x8196 #x8197 #x8199 #x819A #x819E #x819F #x81A0 #x81A1 #x81A2 #x81A4 #x81A5 #x81A7 #x81A9 #x81AB #x81AC #x81AD #x81AE #x81AF #x81B0 #x81B1 #x81B2 #x81B4 #x81B5 #x81B6 #x81B7 #x81B8 #x81B9 #x81BC #x81BD #x81BE #x81BF #x81C4 #x81C5 #x81C7 #x81C8 #x81C9 #x81CB #x81CD #x81CE #x81CF #x81D0 #x81D1 #x81D2 #x81D3 #x81D4 #x81D5 #x81D6 #x81D7 #x81D8 #x81D9 #x81DA #x81DB #x81DC #x81DD #x81DE #x81DF #x81E0 #x81E1 #x81E2 #x81E4 #x81E5 #x81E6 #x81E8 #x81E9 #x81EB #x81EE #x81EF #x81F0 #x81F1 #x81F2 #x81F5 #x81F6 #x81F7 #x81F8 #x81F9 #x81FA #x81FD #x81FF #x8203 #x8207 #x8208 #x8209 #x820A #x820B #x820E #x820F #x8211 #x8213 #x8215 #x8216 #x8217 #x8218 #x8219 #x821A #x821D #x8220 #x8224 #x8225 #x8226 #x8227 #x8229 #x822E #x8232 #x823A #x823C #x823D #x823F #x8240 #x8241 #x8242 #x8243 #x8245 #x8246 #x8248 #x824A #x824C #x824D #x824E #x8250 #x8251 #x8252 #x8253 #x8254 #x8255 #x8256 #x8257 #x8259 #x825B #x825C #x825D #x825E #x8260 #x8261 #x8262 #x8263 #x8264 #x8265 #x8266 #x8267 #x8269 #x826A #x826B #x826C #x826D #x8271 #x8275 #x8276 #x8277 #x8278 #x827B #x827C #x8280 #x8281 #x8283 #x8285 #x8286 #x8287 #x8289 #x828C #x8290 #x8293 #x8294 #x8295 #x8296 #x829A #x829B #x829E #x82A0 #x82A2 #x82A3 #x82A7 #x82B2 #x82B5 #x82B6 #x82BA #x82BB #x82BC #x82BF #x82C0 #x82C2 #x82C3 #x82C5 #x82C6 #x82C9 #x82D0 #x82D6 #x82D9 #x82DA #x82DD #x82E2 #x82E7 #x82E8 #x82E9 #x82EA #x82EC #x82ED #x82EE #x82F0 #x82F2 #x82F3 #x82F5 #x82F6 #x82F8 #x82FA #x82FC #x82FD #x82FE #x82FF #x8300 #x830A #x830B #x830D #x8310 #x8312 #x8313 #x8316 #x8318 #x8319 #x831D #x831E #x831F #x8320 #x8321 #x8322 #x8323 #x8324 #x8325 #x8326 #x8329 #x832A #x832E #x8330 #x8332 #x8337 #x833B #x833D #x833E #x833F #x8341 #x8342 #x8344 #x8345 #x8348 #x834A #x834B #x834C #x834D #x834E #x8353 #x8355 #x8356 #x8357 #x8358 #x8359 #x835D #x8362 #x8370 #x8371 #x8372 #x8373 #x8374 #x8375 #x8376 #x8379 #x837A #x837E #x837F #x8380 #x8381 #x8382 #x8383 #x8384 #x8387 #x8388 #x838A #x838B #x838C #x838D #x838F #x8390 #x8391 #x8394 #x8395 #x8396 #x8397 #x8399 #x839A #x839D #x839F #x83A1 #x83A2 #x83A3 #x83A4 #x83A5 #x83A6 #x83A7 #x83AC #x83AD #x83AE #x83AF #x83B5 #x83BB #x83BE #x83BF #x83C2 #x83C3 #x83C4 #x83C6 #x83C8 #x83C9 #x83CB #x83CD #x83CE #x83D0 #x83D1 #x83D2 #x83D3 #x83D5 #x83D7 #x83D9 #x83DA #x83DB #x83DE #x83E2 #x83E3 #x83E4 #x83E6 #x83E7 #x83E8 #x83EB #x83EC #x83ED #x83EE #x83EF #x83F3 #x83F4 #x83F5 #x83F6 #x83F7 #x83FA #x83FB #x83FC #x83FE #x83FF #x8400 #x8402 #x8405 #x8407 #x8408 #x8409 #x840A #x8410 #x8412 #x8413 #x8414 #x8415 #x8416 #x8417 #x8419 #x841A #x841B #x841E #x841F #x8420 #x8421 #x8422 #x8423 #x8429 #x842A #x842B #x842C #x842D #x842E #x842F #x8430 #x8432 #x8433 #x8434 #x8435 #x8436 #x8437 #x8439 #x843A #x843B #x843E #x843F #x8440 #x8441 #x8442 #x8443 #x8444 #x8445 #x8447 #x8448 #x8449 #x844A #x844B #x844C #x844D #x844E #x844F #x8450 #x8452 #x8453 #x8454 #x8455 #x8456 #x8458 #x845D #x845E #x845F #x8460 #x8462 #x8464 #x8465 #x8466 #x8467 #x8468 #x846A #x846E #x846F #x8470 #x8472 #x8474 #x8477 #x8479 #x847B #x847C #x847D #x847E #x847F #x8480 #x8481 #x8483 #x8484 #x8485 #x8486 #x848A #x848D #x848F #x8490 #x8491 #x8492 #x8493 #x8494 #x8495 #x8496 #x8498 #x849A #x849B #x849D #x849E #x849F #x84A0 #x84A2 #x84A3 #x84A4 #x84A5 #x84A6 #x84A7 #x84A8 #x84A9 #x84AA #x84AB #x84AC #x84AD #x84AE #x84B0 #x84B1 #x84B3 #x84B5 #x84B6 #x84B7 #x84BB #x84BC #x84BE #x84C0 #x84C2 #x84C3 #x84C5 #x84C6 #x84C7 #x84C8 #x84CB #x84CC #x84CE #x84CF #x84D2 #x84D4 #x84D5 #x84D7 #x84D8 #x84D9 #x84DA #x84DB #x84DC #x84DE #x84E1 #x84E2 #x84E4 #x84E7 #x84E8 #x84E9 #x84EA #x84EB #x84ED #x84EE #x84EF #x84F1 #x84F2 #x84F3 #x84F4 #x84F5 #x84F6 #x84F7 #x84F8 #x84F9 #x84FA #x84FB #x84FD #x84FE #x8500 #x8501 #x8502 #x8503 #x8504 #x8505 #x8506 #x8507 #x8508 #x8509 #x850A #x850B #x850D #x850E #x850F #x8510 #x8512 #x8514 #x8515 #x8516 #x8518 #x8519 #x851B #x851C #x851D #x851E #x8520 #x8522 #x8523 #x8524 #x8525 #x8526 #x8527 #x8528 #x8529 #x852A #x852D #x852E #x852F #x8530 #x8531 #x8532 #x8533 #x8534 #x8535 #x8536 #x853E #x853F #x8540 #x8541 #x8542 #x8544 #x8545 #x8546 #x8547 #x854B #x854C #x854D #x854E #x854F #x8550 #x8551 #x8552 #x8553 #x8554 #x8555 #x8557 #x8558 #x855A #x855B #x855C #x855D #x855F #x8560 #x8561 #x8562 #x8563 #x8565 #x8566 #x8567 #x8569 #x856A #x856B #x856C #x856D #x856E #x856F #x8570 #x8571 #x8573 #x8575 #x8576 #x8577 #x8578 #x857C #x857D #x857F #x8580 #x8581 #x8582 #x8583 #x8586 #x8588 #x8589 #x858A #x858B #x858C #x858D #x858E #x8590 #x8591 #x8592 #x8593 #x8594 #x8595 #x8596 #x8597 #x8598 #x8599 #x859A #x859D #x859E #x859F #x85A0 #x85A1 #x85A2 #x85A3 #x85A5 #x85A6 #x85A7 #x85A9 #x85AB #x85AC #x85AD #x85B1 #x85B2 #x85B3 #x85B4 #x85B5 #x85B6 #x85B8 #x85BA #x85BB #x85BC #x85BD #x85BE #x85BF #x85C0 #x85C2 #x85C3 #x85C4 #x85C5 #x85C6 #x85C7 #x85C8 #x85CA #x85CB #x85CC #x85CD #x85CE #x85D1 #x85D2 #x85D4 #x85D6 #x85D7 #x85D8 #x85D9 #x85DA #x85DB #x85DD #x85DE #x85DF #x85E0 #x85E1 #x85E2 #x85E3 #x85E5 #x85E6 #x85E7 #x85E8 #x85EA #x85EB #x85EC #x85ED #x85EE #x85EF #x85F0 #x85F1 #x85F2 #x85F3 #x85F4 #x85F5 #x85F6 #x85F7 #x85F8 #x85F9 #x85FA #x85FC #x85FD #x85FE #x8600 #x8601 #x8602 #x8603 #x8604 #x8606 #x8607 #x8608 #x8609 #x860A #x860B #x860C #x860D #x860E #x860F #x8610 #x8612 #x8613 #x8614 #x8615 #x8617 #x8618 #x8619 #x861A #x861B #x861C #x861D #x861E #x861F #x8620 #x8621 #x8622 #x8623 #x8624 #x8625 #x8626 #x8628 #x862A #x862B #x862C #x862D #x862E #x862F #x8630 #x8631 #x8632 #x8633 #x8634 #x8635 #x8636 #x8637 #x8639 #x863A #x863B #x863D #x863E #x863F #x8640 #x8641 #x8642 #x8643 #x8644 #x8645 #x8646 #x8647 #x8648 #x8649 #x864A #x864B #x864C #x8652 #x8653 #x8655 #x8656 #x8657 #x8658 #x8659 #x865B #x865C #x865D #x865F #x8660 #x8661 #x8663 #x8664 #x8665 #x8666 #x8667 #x8668 #x8669 #x866A #x866D #x866F #x8670 #x8672 #x8673 #x8674 #x8675 #x8676 #x8677 #x8678 #x8683 #x8684 #x8685 #x8686 #x8687 #x8688 #x8689 #x868E #x868F #x8690 #x8691 #x8692 #x8694 #x8696 #x8697 #x8698 #x8699 #x869A #x869B #x869E #x869F #x86A0 #x86A1 #x86A2 #x86A5 #x86A6 #x86AB #x86AD #x86AE #x86B2 #x86B3 #x86B7 #x86B8 #x86B9 #x86BB #x86BC #x86BD #x86BE #x86BF #x86C1 #x86C2 #x86C3 #x86C5 #x86C8 #x86CC #x86CD #x86D2 #x86D3 #x86D5 #x86D6 #x86D7 #x86DA #x86DC #x86DD #x86E0 #x86E1 #x86E2 #x86E3 #x86E5 #x86E6 #x86E7 #x86E8 #x86EA #x86EB #x86EC #x86EF #x86F5 #x86F6 #x86F7 #x86FA #x86FB #x86FC #x86FD #x86FF #x8701 #x8704 #x8705 #x8706 #x870B #x870C #x870E #x870F #x8710 #x8711 #x8714 #x8716 #x8719 #x871B #x871D #x871F #x8720 #x8724 #x8726 #x8727 #x8728 #x872A #x872B #x872C #x872D #x872F #x8730 #x8732 #x8733 #x8735 #x8736 #x8738 #x8739 #x873A #x873C #x873D #x8740 #x8741 #x8742 #x8743 #x8744 #x8745 #x8746 #x874A #x874B #x874D #x874F #x8750 #x8751 #x8752 #x8754 #x8755 #x8756 #x8758 #x875A #x875B #x875C #x875D #x875E #x875F #x8761 #x8762 #x8766 #x8767 #x8768 #x8769 #x876A #x876B #x876C #x876D #x876F #x8771 #x8772 #x8773 #x8775 #x8777 #x8778 #x8779 #x877A #x877F #x8780 #x8781 #x8784 #x8786 #x8787 #x8789 #x878A #x878C #x878E #x878F #x8790 #x8791 #x8792 #x8794 #x8795 #x8796 #x8798 #x8799 #x879A #x879B #x879C #x879D #x879E #x87A0 #x87A1 #x87A2 #x87A3 #x87A4 #x87A5 #x87A6 #x87A7 #x87A9 #x87AA #x87AE #x87B0 #x87B1 #x87B2 #x87B4 #x87B6 #x87B7 #x87B8 #x87B9 #x87BB #x87BC #x87BE #x87BF #x87C1 #x87C2 #x87C3 #x87C4 #x87C5 #x87C7 #x87C8 #x87C9 #x87CC #x87CD #x87CE #x87CF #x87D0 #x87D4 #x87D5 #x87D6 #x87D7 #x87D8 #x87D9 #x87DA #x87DC #x87DD #x87DE #x87DF #x87E1 #x87E2 #x87E3 #x87E4 #x87E6 #x87E7 #x87E8 #x87E9 #x87EB #x87EC #x87ED #x87EF #x87F0 #x87F1 #x87F2 #x87F3 #x87F4 #x87F5 #x87F6 #x87F7 #x87F8 #x87FA #x87FB #x87FC #x87FD #x87FF #x8800 #x8801 #x8802 #x8804 #x8805 #x8806 #x8807 #x8808 #x8809 #x880B #x880C #x880D #x880E #x880F #x8810 #x8811 #x8812 #x8814 #x8817 #x8818 #x8819 #x881A #x881C #x881D #x881E #x881F #x8820 #x8823 #x8824 #x8825 #x8826 #x8827 #x8828 #x8829 #x882A #x882B #x882C #x882D #x882E #x882F #x8830 #x8831 #x8833 #x8834 #x8835 #x8836 #x8837 #x8838 #x883A #x883B #x883D #x883E #x883F #x8841 #x8842 #x8843 #x8846 #x8847 #x8848 #x8849 #x884A #x884B #x884E #x884F #x8850 #x8851 #x8852 #x8853 #x8855 #x8856 #x8858 #x885A #x885B #x885C #x885D #x885E #x885F #x8860 #x8866 #x8867 #x886A #x886D #x886F #x8871 #x8873 #x8874 #x8875 #x8876 #x8878 #x8879 #x887A #x887B #x887C #x8880 #x8883 #x8886 #x8887 #x8889 #x888A #x888C #x888E #x888F #x8890 #x8891 #x8893 #x8894 #x8895 #x8897 #x8898 #x8899 #x889A #x889B #x889D #x889E #x889F #x88A0 #x88A1 #x88A3 #x88A5 #x88A6 #x88A7 #x88A8 #x88A9 #x88AA #x88AC #x88AE #x88AF #x88B0 #x88B2 #x88B3 #x88B4 #x88B5 #x88B6 #x88B8 #x88B9 #x88BA #x88BB #x88BD #x88BE #x88BF #x88C0 #x88C3 #x88C4 #x88C7 #x88C8 #x88CA #x88CB #x88CC #x88CD #x88CF #x88D0 #x88D1 #x88D3 #x88D6 #x88D7 #x88DA #x88DB #x88DC #x88DD #x88DE #x88E0 #x88E1 #x88E6 #x88E7 #x88E9 #x88EA #x88EB #x88EC #x88ED #x88EE #x88EF #x88F2 #x88F5 #x88F6 #x88F7 #x88FA #x88FB #x88FD #x88FF #x8900 #x8901 #x8903 #x8904 #x8905 #x8906 #x8907 #x8908 #x8909 #x890B #x890C #x890D #x890E #x890F #x8911 #x8914 #x8915 #x8916 #x8917 #x8918 #x891C #x891D #x891E #x891F #x8920 #x8922 #x8923 #x8924 #x8926 #x8927 #x8928 #x8929 #x892C #x892D #x892E #x892F #x8931 #x8932 #x8933 #x8935 #x8937 #x8938 #x8939 #x893A #x893B #x893C #x893D #x893E #x893F #x8940 #x8942 #x8943 #x8945 #x8946 #x8947 #x8948 #x8949 #x894A #x894B #x894C #x894D #x894E #x894F #x8950 #x8951 #x8952 #x8953 #x8954 #x8955 #x8956 #x8957 #x8958 #x8959 #x895A #x895B #x895C #x895D #x8960 #x8961 #x8962 #x8963 #x8964 #x8965 #x8967 #x8968 #x8969 #x896A #x896B #x896C #x896D #x896E #x896F #x8970 #x8971 #x8972 #x8973 #x8974 #x8975 #x8976 #x8977 #x8978 #x8979 #x897A #x897C #x897D #x897E #x8980 #x8982 #x8984 #x8985 #x8987 #x8988 #x8989 #x898A #x898B #x898C #x898D #x898E #x898F #x8990 #x8991 #x8992 #x8993 #x8994 #x8995 #x8996 #x8997 #x8998 #x8999 #x899A #x899B #x899C #x899D #x899E #x899F #x89A0 #x89A1 #x89A2 #x89A3 #x89A4 #x89A5 #x89A6 #x89A7 #x89A8 #x89A9 #x89AA #x89AB #x89AC #x89AD #x89AE #x89AF #x89B0 #x89B1 #x89B2 #x89B3 #x89B4 #x89B5 #x89B6 #x89B7 #x89B8 #x89B9 #x89BA #x89BB #x89BC #x89BD #x89BE #x89BF #x89C0 #x89C3 #x89CD #x89D3 #x89D4 #x89D5 #x89D7 #x89D8 #x89D9 #x89DB #x89DD #x89DF #x89E0 #x89E1 #x89E2 #x89E4 #x89E7 #x89E8 #x89E9 #x89EA #x89EC #x89ED #x89EE #x89F0 #x89F1 #x89F2 #x89F4 #x89F5 #x89F6 #x89F7 #x89F8 #x89F9 #x89FA #x89FB #x89FC #x89FD #x89FE #x89FF #x8A01 #x8A02 #x8A03 #x8A04 #x8A05 #x8A06 #x8A08 #x8A09 #x8A0A #x8A0B #x8A0C #x8A0D #x8A0E #x8A0F #x8A10 #x8A11 #x8A12 #x8A13 #x8A14 #x8A15 #x8A16 #x8A17 #x8A18 #x8A19 #x8A1A #x8A1B #x8A1C #x8A1D #x8A1E #x8A1F #x8A20 #x8A21 #x8A22 #x8A23 #x8A24 #x8A25 #x8A26 #x8A27 #x8A28 #x8A29 #x8A2A #x8A2B #x8A2C #x8A2D #x8A2E #x8A2F #x8A30 #x8A31 #x8A32 #x8A33 #x8A34 #x8A35 #x8A36 #x8A37 #x8A38 #x8A39 #x8A3A #x8A3B #x8A3C #x8A3D #x8A3F #x8A40 #x8A41 #x8A42 #x8A43 #x8A44 #x8A45 #x8A46 #x8A47 #x8A49 #x8A4A #x8A4B #x8A4C #x8A4D #x8A4E #x8A4F #x8A50 #x8A51 #x8A52 #x8A53 #x8A54 #x8A55 #x8A56 #x8A57 #x8A58 #x8A59 #x8A5A #x8A5B #x8A5C #x8A5D #x8A5E #x8A5F #x8A60 #x8A61 #x8A62 #x8A63 #x8A64 #x8A65 #x8A66 #x8A67 #x8A68 #x8A69 #x8A6A #x8A6B #x8A6C #x8A6D #x8A6E #x8A6F #x8A70 #x8A71 #x8A72 #x8A73 #x8A74 #x8A75 #x8A76 #x8A77 #x8A78 #x8A7A #x8A7B #x8A7C #x8A7D #x8A7E #x8A7F #x8A80 #x8A81 #x8A82 #x8A83 #x8A84 #x8A85 #x8A86 #x8A87 #x8A88 #x8A8B #x8A8C #x8A8D #x8A8E #x8A8F #x8A90 #x8A91 #x8A92 #x8A94 #x8A95 #x8A96 #x8A97 #x8A98 #x8A99 #x8A9A #x8A9B #x8A9C #x8A9D #x8A9E #x8A9F #x8AA0 #x8AA1 #x8AA2 #x8AA3 #x8AA4 #x8AA5 #x8AA6 #x8AA7 #x8AA8 #x8AA9 #x8AAA #x8AAB #x8AAC #x8AAD #x8AAE #x8AAF #x8AB0 #x8AB1 #x8AB2 #x8AB3 #x8AB4 #x8AB5 #x8AB6 #x8AB7 #x8AB8 #x8AB9 #x8ABA #x8ABB #x8ABC #x8ABD #x8ABE #x8ABF #x8AC0 #x8AC1 #x8AC2 #x8AC3 #x8AC4 #x8AC5 #x8AC6 #x8AC7 #x8AC8 #x8AC9 #x8ACA #x8ACB #x8ACC #x8ACD #x8ACE #x8ACF #x8AD0 #x8AD1 #x8AD2 #x8AD3 #x8AD4 #x8AD5 #x8AD6 #x8AD7 #x8AD8 #x8AD9 #x8ADA #x8ADB #x8ADC #x8ADD #x8ADE #x8ADF #x8AE0 #x8AE1 #x8AE2 #x8AE3 #x8AE4 #x8AE5 #x8AE6 #x8AE7 #x8AE8 #x8AE9 #x8AEA #x8AEB #x8AEC #x8AED #x8AEE #x8AEF #x8AF0 #x8AF1 #x8AF2 #x8AF3 #x8AF4 #x8AF5 #x8AF6 #x8AF7 #x8AF8 #x8AF9 #x8AFA #x8AFB #x8AFC #x8AFD #x8AFE #x8AFF #x8B00 #x8B01 #x8B02 #x8B03 #x8B04 #x8B05 #x8B06 #x8B08 #x8B09 #x8B0A #x8B0B #x8B0C #x8B0D #x8B0E #x8B0F #x8B10 #x8B11 #x8B12 #x8B13 #x8B14 #x8B15 #x8B16 #x8B17 #x8B18 #x8B19 #x8B1A #x8B1B #x8B1C #x8B1D #x8B1E #x8B1F #x8B20 #x8B21 #x8B22 #x8B23 #x8B24 #x8B25 #x8B27 #x8B28 #x8B29 #x8B2A #x8B2B #x8B2C #x8B2D #x8B2E #x8B2F #x8B30 #x8B31 #x8B32 #x8B33 #x8B34 #x8B35 #x8B36 #x8B37 #x8B38 #x8B39 #x8B3A #x8B3B #x8B3C #x8B3D #x8B3E #x8B3F #x8B40 #x8B41 #x8B42 #x8B43 #x8B44 #x8B45 #x8B46 #x8B47 #x8B48 #x8B49 #x8B4A #x8B4B #x8B4C #x8B4D #x8B4E #x8B4F #x8B50 #x8B51 #x8B52 #x8B53 #x8B54 #x8B55 #x8B56 #x8B57 #x8B58 #x8B59 #x8B5A #x8B5B #x8B5C #x8B5D #x8B5E #x8B5F #x8B60 #x8B61 #x8B62 #x8B63 #x8B64 #x8B65 #x8B67 #x8B68 #x8B69 #x8B6A #x8B6B #x8B6D #x8B6E #x8B6F #x8B70 #x8B71 #x8B72 #x8B73 #x8B74 #x8B75 #x8B76 #x8B77 #x8B78 #x8B79 #x8B7A #x8B7B #x8B7C #x8B7D #x8B7E #x8B7F #x8B80 #x8B81 #x8B82 #x8B83 #x8B84 #x8B85 #x8B86 #x8B87 #x8B88 #x8B89 #x8B8A #x8B8B #x8B8C #x8B8D #x8B8E #x8B8F #x8B90 #x8B91 #x8B92 #x8B93 #x8B94 #x8B95 #x8B96 #x8B97 #x8B98 #x8B99 #x8B9A #x8B9B #x8B9C #x8B9D #x8B9E #x8B9F #x8BAC #x8BB1 #x8BBB #x8BC7 #x8BD0 #x8BEA #x8C09 #x8C1E #x8C38 #x8C39 #x8C3A #x8C3B #x8C3C #x8C3D #x8C3E #x8C3F #x8C40 #x8C42 #x8C43 #x8C44 #x8C45 #x8C48 #x8C4A #x8C4B #x8C4D #x8C4E #x8C4F #x8C50 #x8C51 #x8C52 #x8C53 #x8C54 #x8C56 #x8C57 #x8C58 #x8C59 #x8C5B #x8C5C #x8C5D #x8C5E #x8C5F #x8C60 #x8C63 #x8C64 #x8C65 #x8C66 #x8C67 #x8C68 #x8C69 #x8C6C #x8C6D #x8C6E #x8C6F #x8C70 #x8C71 #x8C72 #x8C74 #x8C75 #x8C76 #x8C77 #x8C7B #x8C7C #x8C7D #x8C7E #x8C7F #x8C80 #x8C81 #x8C83 #x8C84 #x8C86 #x8C87 #x8C88 #x8C8B #x8C8D #x8C8E #x8C8F #x8C90 #x8C91 #x8C92 #x8C93 #x8C95 #x8C96 #x8C97 #x8C99 #x8C9A #x8C9B #x8C9C #x8C9D #x8C9E #x8C9F #x8CA0 #x8CA1 #x8CA2 #x8CA3 #x8CA4 #x8CA5 #x8CA6 #x8CA7 #x8CA8 #x8CA9 #x8CAA #x8CAB #x8CAC #x8CAD #x8CAE #x8CAF #x8CB0 #x8CB1 #x8CB2 #x8CB3 #x8CB4 #x8CB5 #x8CB6 #x8CB7 #x8CB8 #x8CB9 #x8CBA #x8CBB #x8CBC #x8CBD #x8CBE #x8CBF #x8CC0 #x8CC1 #x8CC2 #x8CC3 #x8CC4 #x8CC5 #x8CC6 #x8CC7 #x8CC8 #x8CC9 #x8CCA #x8CCB #x8CCC #x8CCD #x8CCE #x8CCF #x8CD0 #x8CD1 #x8CD2 #x8CD3 #x8CD4 #x8CD5 #x8CD6 #x8CD7 #x8CD8 #x8CD9 #x8CDA #x8CDB #x8CDC #x8CDD #x8CDE #x8CDF #x8CE0 #x8CE1 #x8CE2 #x8CE3 #x8CE4 #x8CE5 #x8CE6 #x8CE7 #x8CE8 #x8CE9 #x8CEA #x8CEB #x8CEC #x8CED #x8CEE #x8CEF #x8CF0 #x8CF1 #x8CF2 #x8CF3 #x8CF4 #x8CF5 #x8CF6 #x8CF7 #x8CF8 #x8CF9 #x8CFA #x8CFB #x8CFC #x8CFD #x8CFE #x8CFF #x8D00 #x8D01 #x8D02 #x8D03 #x8D04 #x8D05 #x8D06 #x8D07 #x8D08 #x8D09 #x8D0A #x8D0B #x8D0C #x8D0D #x8D0E #x8D0F #x8D10 #x8D11 #x8D12 #x8D13 #x8D14 #x8D15 #x8D16 #x8D17 #x8D18 #x8D19 #x8D1A #x8D1B #x8D1C #x8D20 #x8D51 #x8D52 #x8D57 #x8D5F #x8D65 #x8D68 #x8D69 #x8D6A #x8D6C #x8D6E #x8D6F #x8D71 #x8D72 #x8D78 #x8D79 #x8D7A #x8D7B #x8D7C #x8D7D #x8D7E #x8D7F #x8D80 #x8D82 #x8D83 #x8D86 #x8D87 #x8D88 #x8D89 #x8D8C #x8D8D #x8D8E #x8D8F #x8D90 #x8D92 #x8D93 #x8D95 #x8D96 #x8D97 #x8D98 #x8D99 #x8D9A #x8D9B #x8D9C #x8D9D #x8D9E #x8DA0 #x8DA1 #x8DA2 #x8DA4 #x8DA5 #x8DA6 #x8DA7 #x8DA8 #x8DA9 #x8DAA #x8DAB #x8DAC #x8DAD #x8DAE #x8DAF #x8DB0 #x8DB2 #x8DB6 #x8DB7 #x8DB9 #x8DBB #x8DBD #x8DC0 #x8DC1 #x8DC2 #x8DC5 #x8DC7 #x8DC8 #x8DC9 #x8DCA #x8DCD #x8DD0 #x8DD2 #x8DD3 #x8DD4 #x8DD5 #x8DD8 #x8DD9 #x8DDC #x8DE0 #x8DE1 #x8DE2 #x8DE5 #x8DE6 #x8DE7 #x8DE9 #x8DED #x8DEE #x8DF0 #x8DF1 #x8DF2 #x8DF4 #x8DF6 #x8DFC #x8DFE #x8DFF #x8E00 #x8E01 #x8E02 #x8E03 #x8E04 #x8E06 #x8E07 #x8E08 #x8E0B #x8E0D #x8E0E #x8E10 #x8E11 #x8E12 #x8E13 #x8E15 #x8E16 #x8E17 #x8E18 #x8E19 #x8E1A #x8E1B #x8E1C #x8E20 #x8E21 #x8E24 #x8E25 #x8E26 #x8E27 #x8E28 #x8E2B #x8E2D #x8E30 #x8E32 #x8E33 #x8E34 #x8E36 #x8E37 #x8E38 #x8E3B #x8E3C #x8E3E #x8E3F #x8E43 #x8E45 #x8E46 #x8E4C #x8E4D #x8E4E #x8E4F #x8E50 #x8E53 #x8E54 #x8E55 #x8E56 #x8E57 #x8E58 #x8E5A #x8E5B #x8E5C #x8E5D #x8E5E #x8E5F #x8E60 #x8E61 #x8E62 #x8E63 #x8E64 #x8E65 #x8E67 #x8E68 #x8E6A #x8E6B #x8E6E #x8E71 #x8E73 #x8E75 #x8E77 #x8E78 #x8E79 #x8E7A #x8E7B #x8E7D #x8E7E #x8E80 #x8E82 #x8E83 #x8E84 #x8E86 #x8E88 #x8E89 #x8E8A #x8E8B #x8E8C #x8E8D #x8E8E #x8E91 #x8E92 #x8E93 #x8E95 #x8E96 #x8E97 #x8E98 #x8E99 #x8E9A #x8E9B #x8E9D #x8E9F #x8EA0 #x8EA1 #x8EA2 #x8EA3 #x8EA4 #x8EA5 #x8EA6 #x8EA7 #x8EA8 #x8EA9 #x8EAA #x8EAD #x8EAE #x8EB0 #x8EB1 #x8EB3 #x8EB4 #x8EB5 #x8EB6 #x8EB7 #x8EB8 #x8EB9 #x8EBB #x8EBC #x8EBD #x8EBE #x8EBF #x8EC0 #x8EC1 #x8EC2 #x8EC3 #x8EC4 #x8EC5 #x8EC6 #x8EC7 #x8EC8 #x8EC9 #x8ECA #x8ECB #x8ECC #x8ECD #x8ECF #x8ED0 #x8ED1 #x8ED2 #x8ED3 #x8ED4 #x8ED5 #x8ED6 #x8ED7 #x8ED8 #x8ED9 #x8EDA #x8EDB #x8EDC #x8EDD #x8EDE #x8EDF #x8EE0 #x8EE1 #x8EE2 #x8EE3 #x8EE4 #x8EE5 #x8EE6 #x8EE7 #x8EE8 #x8EE9 #x8EEA #x8EEB #x8EEC #x8EED #x8EEE #x8EEF #x8EF0 #x8EF1 #x8EF2 #x8EF3 #x8EF4 #x8EF5 #x8EF6 #x8EF7 #x8EF8 #x8EF9 #x8EFA #x8EFB #x8EFC #x8EFD #x8EFE #x8EFF #x8F00 #x8F01 #x8F02 #x8F03 #x8F04 #x8F05 #x8F06 #x8F07 #x8F08 #x8F09 #x8F0A #x8F0B #x8F0C #x8F0D #x8F0E #x8F0F #x8F10 #x8F11 #x8F12 #x8F13 #x8F14 #x8F15 #x8F16 #x8F17 #x8F18 #x8F19 #x8F1A #x8F1B #x8F1C #x8F1D #x8F1E #x8F1F #x8F20 #x8F21 #x8F22 #x8F23 #x8F24 #x8F25 #x8F26 #x8F27 #x8F28 #x8F29 #x8F2A #x8F2B #x8F2C #x8F2D #x8F2E #x8F2F #x8F30 #x8F31 #x8F32 #x8F33 #x8F34 #x8F35 #x8F36 #x8F37 #x8F38 #x8F39 #x8F3A #x8F3B #x8F3C #x8F3D #x8F3E #x8F3F #x8F40 #x8F41 #x8F42 #x8F43 #x8F44 #x8F45 #x8F46 #x8F47 #x8F48 #x8F49 #x8F4A #x8F4B #x8F4C #x8F4D #x8F4E #x8F4F #x8F50 #x8F51 #x8F52 #x8F53 #x8F54 #x8F55 #x8F56 #x8F57 #x8F58 #x8F59 #x8F5A #x8F5B #x8F5C #x8F5D #x8F5E #x8F5F #x8F60 #x8F61 #x8F62 #x8F63 #x8F64 #x8F65 #x8F6A #x8F80 #x8F8C #x8F92 #x8F9D #x8FA0 #x8FA1 #x8FA2 #x8FA4 #x8FA5 #x8FA6 #x8FA7 #x8FAA #x8FAC #x8FAD #x8FAE #x8FAF #x8FB2 #x8FB3 #x8FB4 #x8FB5 #x8FB7 #x8FB8 #x8FBA #x8FBB #x8FBC #x8FBF #x8FC0 #x8FC3 #x8FC6 #x8FC9 #x8FCA #x8FCB #x8FCC #x8FCD #x8FCF #x8FD2 #x8FD6 #x8FD7 #x8FDA #x8FE0 #x8FE1 #x8FE3 #x8FE7 #x8FEC #x8FEF #x8FF1 #x8FF2 #x8FF4 #x8FF5 #x8FF6 #x8FFA #x8FFB #x8FFC #x8FFE #x8FFF #x9007 #x9008 #x900C #x900E #x9013 #x9015 #x9018 #x9019 #x901C #x9023 #x9024 #x9025 #x9027 #x9028 #x9029 #x902A #x902B #x902C #x9030 #x9031 #x9032 #x9033 #x9034 #x9037 #x9039 #x903A #x903D #x903F #x9040 #x9043 #x9045 #x9046 #x9048 #x9049 #x904A #x904B #x904C #x904E #x9054 #x9055 #x9056 #x9059 #x905A #x905C #x905D #x905E #x905F #x9060 #x9061 #x9064 #x9066 #x9067 #x9069 #x906A #x906B #x906C #x906F #x9070 #x9071 #x9072 #x9073 #x9076 #x9077 #x9078 #x9079 #x907A #x907B #x907C #x907E #x9081 #x9084 #x9085 #x9086 #x9087 #x9089 #x908A #x908C #x908D #x908E #x908F #x9090 #x9092 #x9094 #x9096 #x9098 #x909A #x909C #x909E #x909F #x90A0 #x90A4 #x90A5 #x90A7 #x90A8 #x90A9 #x90AB #x90AD #x90B2 #x90B7 #x90BC #x90BD #x90BF #x90C0 #x90C2 #x90C3 #x90C6 #x90C8 #x90C9 #x90CB #x90CC #x90CD #x90D2 #x90D4 #x90D5 #x90D6 #x90D8 #x90D9 #x90DA #x90DE #x90DF #x90E0 #x90E3 #x90E4 #x90E5 #x90E9 #x90EA #x90EC #x90EE #x90F0 #x90F1 #x90F2 #x90F3 #x90F5 #x90F6 #x90F7 #x90F9 #x90FA #x90FB #x90FC #x90FF #x9100 #x9101 #x9103 #x9105 #x9106 #x9107 #x9108 #x9109 #x910A #x910B #x910C #x910D #x910E #x910F #x9110 #x9111 #x9112 #x9113 #x9114 #x9115 #x9116 #x9117 #x9118 #x911A #x911B #x911C #x911D #x911F #x9120 #x9121 #x9124 #x9125 #x9126 #x9127 #x9128 #x9129 #x912A #x912B #x912C #x912D #x912E #x9130 #x9132 #x9133 #x9134 #x9135 #x9136 #x9137 #x9138 #x913A #x913B #x913C #x913D #x913E #x913F #x9140 #x9141 #x9142 #x9144 #x9145 #x9147 #x9148 #x9151 #x9153 #x9154 #x9155 #x9156 #x9158 #x9159 #x915B #x915C #x915F #x9160 #x9166 #x9167 #x9168 #x916B #x916D #x9173 #x917A #x917B #x917C #x9180 #x9181 #x9182 #x9183 #x9184 #x9186 #x9188 #x918A #x918E #x918F #x9193 #x9194 #x9195 #x9196 #x9197 #x9198 #x9199 #x919C #x919D #x919E #x919F #x91A0 #x91A1 #x91A4 #x91A5 #x91A6 #x91A7 #x91A8 #x91A9 #x91AB #x91AC #x91B0 #x91B1 #x91B2 #x91B3 #x91B6 #x91B7 #x91B8 #x91B9 #x91BB #x91BC #x91BD #x91BE #x91BF #x91C0 #x91C1 #x91C2 #x91C3 #x91C4 #x91C5 #x91C6 #x91C8 #x91CB #x91D0 #x91D2 #x91D3 #x91D4 #x91D5 #x91D6 #x91D7 #x91D8 #x91D9 #x91DA #x91DB #x91DD #x91DE #x91DF #x91E0 #x91E1 #x91E2 #x91E3 #x91E4 #x91E5 #x91E6 #x91E7 #x91E8 #x91E9 #x91EA #x91EB #x91EC #x91ED #x91EE #x91EF #x91F0 #x91F1 #x91F2 #x91F3 #x91F4 #x91F5 #x91F6 #x91F7 #x91F8 #x91F9 #x91FA #x91FB #x91FC #x91FD #x91FE #x91FF #x9200 #x9201 #x9202 #x9203 #x9204 #x9205 #x9206 #x9207 #x9208 #x9209 #x920A #x920B #x920C #x920D #x920E #x920F #x9210 #x9211 #x9212 #x9213 #x9214 #x9215 #x9216 #x9217 #x9218 #x9219 #x921A #x921B #x921C #x921D #x921E #x921F #x9220 #x9221 #x9222 #x9223 #x9224 #x9225 #x9226 #x9227 #x9228 #x9229 #x922A #x922B #x922C #x922D #x922E #x922F #x9230 #x9231 #x9232 #x9233 #x9234 #x9235 #x9236 #x9237 #x9238 #x9239 #x923A #x923B #x923C #x923D #x923E #x923F #x9240 #x9241 #x9242 #x9243 #x9244 #x9245 #x9246 #x9247 #x9248 #x9249 #x924A #x924B #x924C #x924D #x924E #x924F #x9250 #x9251 #x9252 #x9253 #x9254 #x9255 #x9256 #x9257 #x9258 #x9259 #x925A #x925B #x925C #x925D #x925E #x925F #x9260 #x9261 #x9262 #x9263 #x9264 #x9265 #x9266 #x9267 #x9268 #x9269 #x926A #x926B #x926C #x926D #x926E #x926F #x9270 #x9271 #x9272 #x9273 #x9275 #x9276 #x9277 #x9278 #x9279 #x927A #x927B #x927C #x927D #x927E #x927F #x9280 #x9281 #x9282 #x9283 #x9284 #x9285 #x9286 #x9287 #x9288 #x9289 #x928A #x928B #x928C #x928D #x928F #x9290 #x9291 #x9292 #x9293 #x9294 #x9295 #x9296 #x9297 #x9298 #x9299 #x929A #x929B #x929C #x929D #x929E #x929F #x92A0 #x92A1 #x92A2 #x92A3 #x92A4 #x92A5 #x92A6 #x92A7 #x92A8 #x92A9 #x92AA #x92AB #x92AC #x92AD #x92AF #x92B0 #x92B1 #x92B2 #x92B3 #x92B4 #x92B5 #x92B6 #x92B7 #x92B8 #x92B9 #x92BA #x92BB #x92BC #x92BD #x92BE #x92BF #x92C0 #x92C1 #x92C2 #x92C3 #x92C4 #x92C5 #x92C6 #x92C7 #x92C9 #x92CA #x92CB #x92CC #x92CD #x92CE #x92CF #x92D0 #x92D1 #x92D2 #x92D3 #x92D4 #x92D5 #x92D6 #x92D7 #x92D8 #x92D9 #x92DA #x92DB #x92DC #x92DD #x92DE #x92DF #x92E0 #x92E1 #x92E2 #x92E3 #x92E4 #x92E5 #x92E6 #x92E7 #x92E8 #x92E9 #x92EA #x92EB #x92EC #x92ED #x92EE #x92EF #x92F0 #x92F1 #x92F2 #x92F3 #x92F4 #x92F5 #x92F6 #x92F7 #x92F8 #x92F9 #x92FA #x92FB #x92FC #x92FD #x92FE #x92FF #x9300 #x9301 #x9302 #x9303 #x9304 #x9305 #x9306 #x9307 #x9308 #x9309 #x930A #x930B #x930C #x930D #x930E #x930F #x9310 #x9311 #x9312 #x9313 #x9314 #x9315 #x9316 #x9317 #x9318 #x9319 #x931A #x931B #x931C #x931D #x931E #x931F #x9320 #x9321 #x9322 #x9323 #x9324 #x9325 #x9326 #x9327 #x9328 #x9329 #x932A #x932B #x932C #x932D #x932E #x932F #x9330 #x9331 #x9332 #x9333 #x9334 #x9335 #x9336 #x9337 #x9338 #x9339 #x933A #x933B #x933C #x933D #x933F #x9340 #x9341 #x9342 #x9343 #x9344 #x9345 #x9346 #x9347 #x9348 #x9349 #x934A #x934B #x934C #x934D #x934E #x934F #x9350 #x9351 #x9352 #x9353 #x9354 #x9355 #x9356 #x9357 #x9358 #x9359 #x935A #x935B #x935C #x935D #x935E #x935F #x9360 #x9361 #x9362 #x9363 #x9364 #x9365 #x9366 #x9367 #x9368 #x9369 #x936B #x936C #x936D #x936E #x936F #x9370 #x9371 #x9372 #x9373 #x9374 #x9375 #x9376 #x9377 #x9378 #x9379 #x937A #x937B #x937C #x937D #x937E #x937F #x9380 #x9381 #x9382 #x9383 #x9384 #x9385 #x9386 #x9387 #x9388 #x9389 #x938A #x938B #x938C #x938D #x938E #x9390 #x9391 #x9392 #x9393 #x9394 #x9395 #x9396 #x9397 #x9398 #x9399 #x939A #x939B #x939C #x939D #x939E #x939F #x93A0 #x93A1 #x93A2 #x93A3 #x93A4 #x93A5 #x93A6 #x93A7 #x93A8 #x93A9 #x93AA #x93AB #x93AC #x93AD #x93AE #x93AF #x93B0 #x93B1 #x93B2 #x93B3 #x93B4 #x93B5 #x93B6 #x93B7 #x93B8 #x93B9 #x93BA #x93BB #x93BC #x93BD #x93BE #x93BF #x93C0 #x93C1 #x93C2 #x93C3 #x93C4 #x93C5 #x93C6 #x93C7 #x93C8 #x93C9 #x93CB #x93CC #x93CD #x93CE #x93CF #x93D0 #x93D1 #x93D2 #x93D3 #x93D4 #x93D5 #x93D7 #x93D8 #x93D9 #x93DA #x93DB #x93DC #x93DD #x93DE #x93DF #x93E0 #x93E1 #x93E2 #x93E3 #x93E4 #x93E5 #x93E6 #x93E7 #x93E8 #x93E9 #x93EA #x93EB #x93EC #x93ED #x93EE #x93EF #x93F0 #x93F1 #x93F2 #x93F3 #x93F4 #x93F5 #x93F6 #x93F7 #x93F8 #x93F9 #x93FA #x93FB #x93FC #x93FD #x93FE #x93FF #x9400 #x9401 #x9402 #x9403 #x9404 #x9405 #x9406 #x9407 #x9408 #x9409 #x940A #x940B #x940C #x940D #x940E #x940F #x9410 #x9411 #x9412 #x9413 #x9414 #x9415 #x9416 #x9417 #x9418 #x9419 #x941A #x941B #x941C #x941D #x941E #x941F #x9420 #x9421 #x9422 #x9423 #x9424 #x9425 #x9426 #x9427 #x9428 #x9429 #x942A #x942B #x942C #x942D #x942E #x942F #x9430 #x9431 #x9432 #x9433 #x9434 #x9435 #x9436 #x9437 #x9438 #x9439 #x943A #x943B #x943C #x943D #x943F #x9440 #x9441 #x9442 #x9443 #x9444 #x9445 #x9446 #x9447 #x9448 #x9449 #x944A #x944B #x944C #x944D #x944E #x944F #x9450 #x9451 #x9452 #x9453 #x9454 #x9455 #x9456 #x9457 #x9458 #x9459 #x945A #x945B #x945C #x945D #x945E #x945F #x9460 #x9461 #x9462 #x9463 #x9464 #x9465 #x9466 #x9467 #x9468 #x9469 #x946A #x946C #x946D #x946E #x946F #x9470 #x9471 #x9472 #x9473 #x9474 #x9475 #x9476 #x9477 #x9478 #x9479 #x947A #x947B #x947C #x947D #x947E #x947F #x9480 #x9481 #x9482 #x9483 #x9484 #x9491 #x9496 #x9498 #x94C7 #x94CF #x94D3 #x94D4 #x94DA #x94E6 #x94FB #x951C #x9520 #x9527 #x9533 #x953D #x9543 #x9548 #x954B #x9555 #x955A #x9560 #x956E #x9574 #x9575 #x9577 #x9578 #x9579 #x957A #x957B #x957C #x957D #x957E #x9580 #x9581 #x9582 #x9583 #x9584 #x9585 #x9586 #x9587 #x9588 #x9589 #x958A #x958B #x958C #x958D #x958E #x958F #x9590 #x9591 #x9592 #x9593 #x9594 #x9595 #x9596 #x9597 #x9598 #x9599 #x959A #x959B #x959C #x959D #x959E #x959F #x95A0 #x95A1 #x95A2 #x95A3 #x95A4 #x95A5 #x95A6 #x95A7 #x95A8 #x95A9 #x95AA #x95AB #x95AC #x95AD #x95AE #x95AF #x95B0 #x95B1 #x95B2 #x95B3 #x95B4 #x95B5 #x95B6 #x95B7 #x95B8 #x95B9 #x95BA #x95BB #x95BC #x95BD #x95BE #x95BF #x95C0 #x95C1 #x95C2 #x95C3 #x95C4 #x95C5 #x95C6 #x95C7 #x95C8 #x95C9 #x95CA #x95CB #x95CC #x95CD #x95CE #x95CF #x95D0 #x95D1 #x95D2 #x95D3 #x95D4 #x95D5 #x95D6 #x95D7 #x95D8 #x95D9 #x95DA #x95DB #x95DC #x95DD #x95DE #x95DF #x95E0 #x95E1 #x95E2 #x95E3 #x95E4 #x95E5 #x95E6 #x95E7 #x95EC #x95FF #x9607 #x9613 #x9618 #x961B #x961E #x9620 #x9623 #x9624 #x9625 #x9626 #x9627 #x9628 #x9629 #x962B #x962C #x962D #x962F #x9630 #x9637 #x9638 #x9639 #x963A #x963E #x9641 #x9643 #x964A #x964E #x964F #x9651 #x9652 #x9653 #x9656 #x9657 #x9658 #x9659 #x965A #x965C #x965D #x965E #x9660 #x9663 #x9665 #x9666 #x966B #x966D #x966E #x966F #x9670 #x9671 #x9673 #x9678 #x9679 #x967A #x967B #x967C #x967D #x967E #x967F #x9680 #x9681 #x9682 #x9683 #x9684 #x9687 #x9689 #x968A #x968C #x968E #x9691 #x9692 #x9693 #x9695 #x9696 #x969A #x969B #x969D #x969E #x969F #x96A0 #x96A1 #x96A2 #x96A3 #x96A4 #x96A5 #x96A6 #x96A8 #x96A9 #x96AA #x96AB #x96AC #x96AD #x96AE #x96AF #x96B1 #x96B2 #x96B4 #x96B5 #x96B7 #x96B8 #x96BA #x96BB #x96BF #x96C2 #x96C3 #x96C8 #x96CA #x96CB #x96D0 #x96D1 #x96D3 #x96D4 #x96D6 #x96D7 #x96D8 #x96D9 #x96DA #x96DB #x96DC #x96DD #x96DE #x96DF #x96E1 #x96E2 #x96E3 #x96E4 #x96E5 #x96E6 #x96E7 #x96EB #x96EC #x96ED #x96EE #x96F0 #x96F1 #x96F2 #x96F4 #x96F5 #x96F8 #x96FA #x96FB #x96FC #x96FD #x96FF #x9702 #x9703 #x9705 #x970A #x970B #x970C #x9710 #x9711 #x9712 #x9714 #x9715 #x9717 #x9718 #x9719 #x971A #x971B #x971D #x971F #x9720 #x9721 #x9722 #x9723 #x9724 #x9725 #x9726 #x9727 #x9728 #x9729 #x972B #x972C #x972E #x972F #x9731 #x9733 #x9734 #x9735 #x9736 #x9737 #x973A #x973B #x973C #x973D #x973F #x9740 #x9741 #x9742 #x9743 #x9744 #x9745 #x9746 #x9747 #x9748 #x9749 #x974A #x974B #x974C #x974D #x974E #x974F #x9750 #x9751 #x9754 #x9755 #x9757 #x9758 #x975A #x975C #x975D #x975F #x9763 #x9764 #x9766 #x9767 #x9768 #x976A #x976B #x976C #x976D #x976E #x976F #x9770 #x9771 #x9772 #x9775 #x9777 #x9778 #x9779 #x977A #x977B #x977D #x977E #x977F #x9780 #x9781 #x9782 #x9783 #x9784 #x9786 #x9787 #x9788 #x9789 #x978A #x978C #x978E #x978F #x9790 #x9793 #x9795 #x9796 #x9797 #x9799 #x979A #x979B #x979C #x979D #x979E #x979F #x97A1 #x97A2 #x97A4 #x97A5 #x97A6 #x97A7 #x97A8 #x97A9 #x97AA #x97AC #x97AE #x97B0 #x97B1 #x97B3 #x97B5 #x97B6 #x97B7 #x97B8 #x97B9 #x97BA #x97BB #x97BC #x97BD #x97BE #x97BF #x97C0 #x97C1 #x97C2 #x97C3 #x97C4 #x97C5 #x97C6 #x97C7 #x97C8 #x97C9 #x97CA #x97CB #x97CC #x97CD #x97CE #x97CF #x97D0 #x97D1 #x97D2 #x97D3 #x97D4 #x97D5 #x97D6 #x97D7 #x97D8 #x97D9 #x97DA #x97DB #x97DC #x97DD #x97DE #x97DF #x97E0 #x97E1 #x97E2 #x97E3 #x97E4 #x97E5 #x97E8 #x97EE #x97EF #x97F0 #x97F1 #x97F2 #x97F4 #x97F7 #x97F8 #x97F9 #x97FA #x97FB #x97FC #x97FD #x97FE #x97FF #x9800 #x9801 #x9802 #x9803 #x9804 #x9805 #x9806 #x9807 #x9808 #x9809 #x980A #x980B #x980C #x980D #x980E #x980F #x9810 #x9811 #x9812 #x9813 #x9814 #x9815 #x9816 #x9817 #x9818 #x9819 #x981A #x981B #x981C #x981D #x981E #x981F #x9820 #x9821 #x9822 #x9823 #x9824 #x9825 #x9826 #x9827 #x9828 #x9829 #x982A #x982B #x982C #x982D #x982E #x982F #x9830 #x9831 #x9832 #x9833 #x9834 #x9835 #x9836 #x9837 #x9838 #x9839 #x983A #x983B #x983C #x983D #x983E #x983F #x9840 #x9841 #x9842 #x9843 #x9844 #x9845 #x9846 #x9847 #x9848 #x9849 #x984A #x984B #x984C #x984D #x984E #x984F #x9850 #x9851 #x9852 #x9853 #x9854 #x9855 #x9856 #x9857 #x9858 #x9859 #x985A #x985B #x985C #x985D #x985E #x985F #x9860 #x9861 #x9862 #x9863 #x9864 #x9865 #x9866 #x9867 #x9868 #x9869 #x986A #x986B #x986C #x986D #x986E #x986F #x9870 #x9871 #x9872 #x9873 #x9874 #x988B #x988E #x9892 #x9895 #x9899 #x98A3 #x98A8 #x98A9 #x98AA #x98AB #x98AC #x98AD #x98AE #x98AF #x98B0 #x98B1 #x98B2 #x98B3 #x98B4 #x98B5 #x98B6 #x98B7 #x98B8 #x98B9 #x98BA #x98BB #x98BC #x98BD #x98BE #x98BF #x98C0 #x98C1 #x98C2 #x98C3 #x98C4 #x98C5 #x98C6 #x98C7 #x98C8 #x98C9 #x98CA #x98CB #x98CC #x98CD #x98CF #x98D0 #x98D4 #x98D6 #x98D7 #x98DB #x98DC #x98DD #x98E0 #x98E1 #x98E2 #x98E3 #x98E4 #x98E5 #x98E6 #x98E9 #x98EA #x98EB #x98EC #x98ED #x98EE #x98EF #x98F0 #x98F1 #x98F2 #x98F3 #x98F4 #x98F5 #x98F6 #x98F7 #x98F8 #x98F9 #x98FA #x98FB #x98FC #x98FD #x98FE #x98FF #x9900 #x9901 #x9902 #x9903 #x9904 #x9905 #x9906 #x9907 #x9908 #x9909 #x990A #x990B #x990C #x990E #x990F #x9911 #x9912 #x9913 #x9914 #x9915 #x9916 #x9917 #x9918 #x9919 #x991A #x991B #x991C #x991D #x991E #x991F #x9920 #x9921 #x9922 #x9923 #x9924 #x9925 #x9926 #x9927 #x9928 #x9929 #x992A #x992B #x992C #x992D #x992F #x9930 #x9931 #x9932 #x9933 #x9934 #x9935 #x9936 #x9937 #x9938 #x9939 #x993A #x993B #x993C #x993D #x993E #x993F #x9940 #x9941 #x9942 #x9943 #x9944 #x9945 #x9946 #x9947 #x9948 #x9949 #x994A #x994B #x994C #x994D #x994E #x994F #x9950 #x9951 #x9952 #x9953 #x9956 #x9957 #x9958 #x9959 #x995A #x995B #x995C #x995D #x995E #x995F #x9960 #x9961 #x9962 #x9964 #x9966 #x9973 #x9978 #x9979 #x997B #x997E #x9982 #x9983 #x9989 #x998C #x998E #x999A #x999B #x999C #x999D #x999E #x999F #x99A0 #x99A1 #x99A2 #x99A3 #x99A4 #x99A6 #x99A7 #x99A9 #x99AA #x99AB #x99AC #x99AD #x99AE #x99AF #x99B0 #x99B1 #x99B2 #x99B3 #x99B4 #x99B5 #x99B6 #x99B7 #x99B8 #x99B9 #x99BA #x99BB #x99BC #x99BD #x99BE #x99BF #x99C0 #x99C1 #x99C2 #x99C3 #x99C4 #x99C5 #x99C6 #x99C7 #x99C8 #x99C9 #x99CA #x99CB #x99CC #x99CD #x99CE #x99CF #x99D0 #x99D1 #x99D2 #x99D3 #x99D4 #x99D5 #x99D6 #x99D7 #x99D8 #x99D9 #x99DA #x99DB #x99DC #x99DD #x99DE #x99DF #x99E0 #x99E1 #x99E2 #x99E3 #x99E4 #x99E5 #x99E6 #x99E7 #x99E8 #x99E9 #x99EA #x99EB #x99EC #x99ED #x99EE #x99EF #x99F0 #x99F1 #x99F2 #x99F3 #x99F4 #x99F5 #x99F6 #x99F7 #x99F8 #x99F9 #x99FA #x99FB #x99FC #x99FD #x99FE #x99FF #x9A00 #x9A01 #x9A02 #x9A03 #x9A04 #x9A05 #x9A06 #x9A07 #x9A08 #x9A09 #x9A0A #x9A0B #x9A0C #x9A0D #x9A0E #x9A0F #x9A10 #x9A11 #x9A12 #x9A13 #x9A14 #x9A15 #x9A16 #x9A17 #x9A18 #x9A19 #x9A1A #x9A1B #x9A1C #x9A1D #x9A1E #x9A1F #x9A20 #x9A21 #x9A22 #x9A23 #x9A24 #x9A25 #x9A26 #x9A27 #x9A28 #x9A29 #x9A2A #x9A2B #x9A2C #x9A2D #x9A2E #x9A2F #x9A30 #x9A31 #x9A32 #x9A33 #x9A34 #x9A35 #x9A36 #x9A37 #x9A38 #x9A39 #x9A3A #x9A3B #x9A3C #x9A3D #x9A3E #x9A3F #x9A40 #x9A41 #x9A42 #x9A43 #x9A44 #x9A45 #x9A46 #x9A47 #x9A48 #x9A49 #x9A4A #x9A4B #x9A4C #x9A4D #x9A4E #x9A4F #x9A50 #x9A51 #x9A52 #x9A53 #x9A54 #x9A55 #x9A56 #x9A57 #x9A58 #x9A59 #x9A5A #x9A5B #x9A5C #x9A5D #x9A5E #x9A5F #x9A60 #x9A61 #x9A62 #x9A63 #x9A64 #x9A65 #x9A66 #x9A67 #x9A68 #x9A69 #x9A6A #x9A6B #x9A72 #x9A83 #x9A89 #x9A8D #x9A8E #x9A94 #x9A95 #x9A99 #x9AA6 #x9AA9 #x9AAA #x9AAB #x9AAC #x9AAD #x9AAE #x9AAF #x9AB2 #x9AB3 #x9AB4 #x9AB5 #x9AB9 #x9ABB #x9ABD #x9ABE #x9ABF #x9AC3 #x9AC4 #x9AC6 #x9AC7 #x9AC8 #x9AC9 #x9ACA #x9ACD #x9ACE #x9ACF #x9AD0 #x9AD2 #x9AD4 #x9AD5 #x9AD6 #x9AD7 #x9AD9 #x9ADA #x9ADB #x9ADC #x9ADD #x9ADE #x9AE0 #x9AE2 #x9AE3 #x9AE4 #x9AE5 #x9AE7 #x9AE8 #x9AE9 #x9AEA #x9AEC #x9AEE #x9AF0 #x9AF1 #x9AF2 #x9AF3 #x9AF4 #x9AF5 #x9AF6 #x9AF7 #x9AF8 #x9AFA #x9AFC #x9AFD #x9AFE #x9AFF #x9B00 #x9B01 #x9B02 #x9B04 #x9B05 #x9B06 #x9B07 #x9B09 #x9B0A #x9B0B #x9B0C #x9B0D #x9B0E #x9B10 #x9B11 #x9B12 #x9B14 #x9B15 #x9B16 #x9B17 #x9B18 #x9B19 #x9B1A #x9B1B #x9B1C #x9B1D #x9B1E #x9B20 #x9B21 #x9B22 #x9B24 #x9B25 #x9B26 #x9B27 #x9B28 #x9B29 #x9B2A #x9B2B #x9B2C #x9B2D #x9B2E #x9B30 #x9B31 #x9B33 #x9B34 #x9B35 #x9B36 #x9B37 #x9B38 #x9B39 #x9B3A #x9B3D #x9B3E #x9B3F #x9B40 #x9B46 #x9B4A #x9B4B #x9B4C #x9B4E #x9B50 #x9B52 #x9B53 #x9B55 #x9B56 #x9B57 #x9B58 #x9B59 #x9B5A #x9B5B #x9B5C #x9B5D #x9B5E #x9B5F #x9B60 #x9B61 #x9B62 #x9B63 #x9B64 #x9B65 #x9B66 #x9B67 #x9B68 #x9B69 #x9B6A #x9B6B #x9B6C #x9B6D #x9B6E #x9B6F #x9B70 #x9B71 #x9B72 #x9B73 #x9B74 #x9B75 #x9B76 #x9B77 #x9B78 #x9B79 #x9B7A #x9B7B #x9B7C #x9B7D #x9B7E #x9B7F #x9B80 #x9B81 #x9B82 #x9B83 #x9B84 #x9B85 #x9B86 #x9B87 #x9B88 #x9B89 #x9B8A #x9B8B #x9B8C #x9B8D #x9B8E #x9B8F #x9B90 #x9B91 #x9B92 #x9B93 #x9B94 #x9B95 #x9B96 #x9B97 #x9B98 #x9B99 #x9B9A #x9B9B #x9B9C #x9B9D #x9B9E #x9B9F #x9BA0 #x9BA1 #x9BA2 #x9BA3 #x9BA4 #x9BA5 #x9BA6 #x9BA7 #x9BA8 #x9BA9 #x9BAA #x9BAB #x9BAC #x9BAD #x9BAE #x9BAF #x9BB0 #x9BB1 #x9BB2 #x9BB3 #x9BB4 #x9BB5 #x9BB6 #x9BB7 #x9BB8 #x9BB9 #x9BBA #x9BBB #x9BBC #x9BBD #x9BBE #x9BBF #x9BC0 #x9BC1 #x9BC2 #x9BC3 #x9BC4 #x9BC5 #x9BC6 #x9BC7 #x9BC8 #x9BC9 #x9BCA #x9BCB #x9BCC #x9BCD #x9BCE #x9BCF #x9BD0 #x9BD1 #x9BD2 #x9BD3 #x9BD4 #x9BD5 #x9BD6 #x9BD7 #x9BD8 #x9BD9 #x9BDA #x9BDB #x9BDC #x9BDD #x9BDE #x9BDF #x9BE0 #x9BE1 #x9BE2 #x9BE3 #x9BE4 #x9BE5 #x9BE6 #x9BE7 #x9BE8 #x9BE9 #x9BEA #x9BEB #x9BEC #x9BED #x9BEE #x9BEF #x9BF0 #x9BF1 #x9BF2 #x9BF3 #x9BF4 #x9BF5 #x9BF6 #x9BF7 #x9BF8 #x9BF9 #x9BFA #x9BFB #x9BFC #x9BFD #x9BFE #x9BFF #x9C00 #x9C01 #x9C02 #x9C03 #x9C04 #x9C05 #x9C06 #x9C07 #x9C08 #x9C09 #x9C0A #x9C0B #x9C0C #x9C0D #x9C0E #x9C0F #x9C10 #x9C11 #x9C12 #x9C13 #x9C14 #x9C15 #x9C16 #x9C17 #x9C18 #x9C19 #x9C1A #x9C1B #x9C1C #x9C1D #x9C1E #x9C1F #x9C20 #x9C21 #x9C22 #x9C23 #x9C24 #x9C25 #x9C26 #x9C27 #x9C28 #x9C29 #x9C2A #x9C2B #x9C2C #x9C2D #x9C2E #x9C2F #x9C30 #x9C31 #x9C32 #x9C33 #x9C34 #x9C35 #x9C36 #x9C37 #x9C38 #x9C39 #x9C3A #x9C3B #x9C3C #x9C3D #x9C3E #x9C3F #x9C40 #x9C41 #x9C42 #x9C43 #x9C44 #x9C45 #x9C46 #x9C47 #x9C48 #x9C49 #x9C4A #x9C4B #x9C4C #x9C4D #x9C4E #x9C4F #x9C50 #x9C51 #x9C52 #x9C53 #x9C54 #x9C55 #x9C56 #x9C57 #x9C58 #x9C59 #x9C5A #x9C5B #x9C5C #x9C5D #x9C5E #x9C5F #x9C60 #x9C61 #x9C62 #x9C63 #x9C64 #x9C65 #x9C66 #x9C67 #x9C68 #x9C69 #x9C6A #x9C6B #x9C6C #x9C6D #x9C6E #x9C6F #x9C70 #x9C71 #x9C72 #x9C73 #x9C74 #x9C75 #x9C76 #x9C77 #x9C78 #x9C79 #x9C7A #x9C7B #x9C7D #x9C7E #x9C80 #x9C83 #x9C84 #x9C89 #x9C8A #x9C8C #x9C8F #x9C93 #x9C96 #x9C97 #x9C98 #x9C99 #x9C9D #x9CAA #x9CAC #x9CAF #x9CB9 #x9CBE #x9CBF #x9CC0 #x9CC1 #x9CC2 #x9CC8 #x9CC9 #x9CD1 #x9CD2 #x9CDA #x9CDB #x9CE0 #x9CE1 #x9CE3 #x9CE4 #x9CE5 #x9CE6 #x9CE7 #x9CE8 #x9CE9 #x9CEA #x9CEB #x9CEC #x9CED #x9CEE #x9CEF #x9CF0 #x9CF1 #x9CF2 #x9CF3 #x9CF4 #x9CF5 #x9CF6 #x9CF7 #x9CF8 #x9CF9 #x9CFA #x9CFB #x9CFC #x9CFD #x9CFE #x9CFF #x9D00 #x9D01 #x9D02 #x9D03 #x9D04 #x9D05 #x9D06 #x9D07 #x9D08 #x9D09 #x9D0A #x9D0B #x9D0C #x9D0D #x9D0E #x9D0F #x9D10 #x9D11 #x9D12 #x9D13 #x9D14 #x9D15 #x9D16 #x9D17 #x9D18 #x9D19 #x9D1A #x9D1B #x9D1C #x9D1D #x9D1E #x9D1F #x9D20 #x9D21 #x9D22 #x9D23 #x9D24 #x9D25 #x9D26 #x9D27 #x9D28 #x9D29 #x9D2A #x9D2B #x9D2C #x9D2D #x9D2E #x9D2F #x9D30 #x9D31 #x9D32 #x9D33 #x9D34 #x9D35 #x9D36 #x9D37 #x9D38 #x9D39 #x9D3A #x9D3B #x9D3C #x9D3D #x9D3E #x9D3F #x9D40 #x9D41 #x9D42 #x9D43 #x9D44 #x9D45 #x9D46 #x9D47 #x9D48 #x9D49 #x9D4A #x9D4B #x9D4C #x9D4D #x9D4E #x9D4F #x9D50 #x9D51 #x9D52 #x9D53 #x9D54 #x9D55 #x9D56 #x9D57 #x9D58 #x9D59 #x9D5A #x9D5B #x9D5C #x9D5D #x9D5E #x9D5F #x9D60 #x9D61 #x9D62 #x9D63 #x9D64 #x9D65 #x9D66 #x9D67 #x9D68 #x9D69 #x9D6A #x9D6B #x9D6C #x9D6D #x9D6E #x9D6F #x9D70 #x9D71 #x9D72 #x9D73 #x9D74 #x9D75 #x9D76 #x9D77 #x9D78 #x9D79 #x9D7A #x9D7B #x9D7C #x9D7D #x9D7E #x9D7F #x9D80 #x9D81 #x9D82 #x9D83 #x9D84 #x9D85 #x9D86 #x9D87 #x9D88 #x9D89 #x9D8A #x9D8B #x9D8C #x9D8D #x9D8E #x9D8F #x9D90 #x9D91 #x9D92 #x9D93 #x9D94 #x9D95 #x9D96 #x9D97 #x9D98 #x9D99 #x9D9A #x9D9B #x9D9C #x9D9D #x9D9E #x9D9F #x9DA0 #x9DA1 #x9DA2 #x9DA3 #x9DA4 #x9DA5 #x9DA6 #x9DA7 #x9DA8 #x9DA9 #x9DAA #x9DAB #x9DAC #x9DAD #x9DAE #x9DAF #x9DB0 #x9DB1 #x9DB2 #x9DB3 #x9DB4 #x9DB5 #x9DB6 #x9DB7 #x9DB8 #x9DB9 #x9DBA #x9DBB #x9DBC #x9DBD #x9DBE #x9DBF #x9DC0 #x9DC1 #x9DC2 #x9DC3 #x9DC4 #x9DC5 #x9DC6 #x9DC7 #x9DC8 #x9DC9 #x9DCA #x9DCB #x9DCC #x9DCD #x9DCE #x9DCF #x9DD0 #x9DD1 #x9DD2 #x9DD3 #x9DD4 #x9DD5 #x9DD6 #x9DD7 #x9DD8 #x9DD9 #x9DDA #x9DDB #x9DDC #x9DDD #x9DDE #x9DDF #x9DE0 #x9DE1 #x9DE2 #x9DE3 #x9DE4 #x9DE5 #x9DE6 #x9DE7 #x9DE8 #x9DE9 #x9DEA #x9DEB #x9DEC #x9DED #x9DEE #x9DEF #x9DF0 #x9DF1 #x9DF2 #x9DF3 #x9DF4 #x9DF5 #x9DF6 #x9DF7 #x9DF8 #x9DF9 #x9DFA #x9DFB #x9DFC #x9DFD #x9DFE #x9DFF #x9E00 #x9E01 #x9E02 #x9E03 #x9E04 #x9E05 #x9E06 #x9E07 #x9E08 #x9E09 #x9E0A #x9E0B #x9E0C #x9E0D #x9E0E #x9E0F #x9E10 #x9E11 #x9E12 #x9E13 #x9E14 #x9E15 #x9E16 #x9E17 #x9E18 #x9E19 #x9E1A #x9E1B #x9E1C #x9E1D #x9E1E #x9E24 #x9E27 #x9E2E #x9E30 #x9E34 #x9E3B #x9E3C #x9E40 #x9E4D #x9E50 #x9E52 #x9E53 #x9E54 #x9E56 #x9E59 #x9E5D #x9E5F #x9E60 #x9E61 #x9E62 #x9E65 #x9E6E #x9E6F #x9E72 #x9E74 #x9E75 #x9E76 #x9E77 #x9E78 #x9E79 #x9E7A #x9E7B #x9E7C #x9E7D #x9E80 #x9E81 #x9E83 #x9E84 #x9E85 #x9E86 #x9E89 #x9E8A #x9E8C #x9E8D #x9E8E #x9E8F #x9E90 #x9E91 #x9E94 #x9E95 #x9E96 #x9E97 #x9E98 #x9E99 #x9E9A #x9E9B #x9E9C #x9E9E #x9EA0 #x9EA1 #x9EA2 #x9EA3 #x9EA4 #x9EA5 #x9EA7 #x9EA8 #x9EA9 #x9EAA #x9EAB #x9EAC #x9EAD #x9EAE #x9EAF #x9EB0 #x9EB1 #x9EB2 #x9EB3 #x9EB5 #x9EB6 #x9EB7 #x9EB9 #x9EBA #x9EBC #x9EBF #x9EC0 #x9EC1 #x9EC2 #x9EC3 #x9EC5 #x9EC6 #x9EC7 #x9EC8 #x9ECA #x9ECB #x9ECC #x9ED0 #x9ED2 #x9ED3 #x9ED5 #x9ED6 #x9ED7 #x9ED9 #x9EDA #x9EDE #x9EE1 #x9EE3 #x9EE4 #x9EE6 #x9EE8 #x9EEB #x9EEC #x9EED #x9EEE #x9EF0 #x9EF1 #x9EF2 #x9EF3 #x9EF4 #x9EF5 #x9EF6 #x9EF7 #x9EF8 #x9EFA #x9EFD #x9EFF #x9F00 #x9F01 #x9F02 #x9F03 #x9F04 #x9F05 #x9F06 #x9F07 #x9F08 #x9F09 #x9F0A #x9F0C #x9F0F #x9F11 #x9F12 #x9F14 #x9F15 #x9F16 #x9F18 #x9F1A #x9F1B #x9F1C #x9F1D #x9F1E #x9F1F #x9F21 #x9F23 #x9F24 #x9F25 #x9F26 #x9F27 #x9F28 #x9F29 #x9F2A #x9F2B #x9F2D #x9F2E #x9F30 #x9F31 #x9F32 #x9F33 #x9F34 #x9F35 #x9F36 #x9F38 #x9F3A #x9F3C #x9F3F #x9F40 #x9F41 #x9F42 #x9F43 #x9F45 #x9F46 #x9F47 #x9F48 #x9F49 #x9F4A #x9F4B #x9F4C #x9F4D #x9F4E #x9F4F #x9F52 #x9F53 #x9F54 #x9F55 #x9F56 #x9F57 #x9F58 #x9F59 #x9F5A #x9F5B #x9F5C #x9F5D #x9F5E #x9F5F #x9F60 #x9F61 #x9F62 #x9F63 #x9F64 #x9F65 #x9F66 #x9F67 #x9F68 #x9F69 #x9F6A #x9F6B #x9F6C #x9F6D #x9F6E #x9F6F #x9F70 #x9F71 #x9F72 #x9F73 #x9F74 #x9F75 #x9F76 #x9F77 #x9F78 #x9F79 #x9F7A #x9F7B #x9F7C #x9F7D #x9F7E #x9F81 #x9F82 #x9F8D #x9F8E #x9F8F #x9F90 #x9F91 #x9F92 #x9F93 #x9F94 #x9F95 #x9F96 #x9F97 #x9F98 #x9F9C #x9F9D #x9F9E #x9FA1 #x9FA2 #x9FA3 #x9FA4 #x9FA5 #x3000 #x3001 #x3002 #x00B7 #x02C9 #x02C7 #x00A8 #x3003 #x3005 #x2014 #xFF5E #x2016 #x2026 #x2018 #x2019 #x201C #x201D #x3014 #x3015 #x3008 #x3009 #x300A #x300B #x300C #x300D #x300E #x300F #x3016 #x3017 #x3010 #x3011 #x00B1 #x00D7 #x00F7 #x2236 #x2227 #x2228 #x2211 #x220F #x222A #x2229 #x2208 #x2237 #x221A #x22A5 #x2225 #x2220 #x2312 #x2299 #x222B #x222E #x2261 #x224C #x2248 #x223D #x221D #x2260 #x226E #x226F #x2264 #x2265 #x221E #x2235 #x2234 #x2642 #x2640 #x00B0 #x2032 #x2033 #x2103 #xFF04 #x00A4 #xFFE0 #xFFE1 #x2030 #x00A7 #x2116 #x2606 #x2605 #x25CB #x25CF #x25CE #x25C7 #x25C6 #x25A1 #x25A0 #x25B3 #x25B2 #x203B #x2192 #x2190 #x2191 #x2193 #x3013 #x2170 #x2171 #x2172 #x2173 #x2174 #x2175 #x2176 #x2177 #x2178 #x2179 #xE766 #xE767 #xE768 #xE769 #xE76A #xE76B #x2488 #x2489 #x248A #x248B #x248C #x248D #x248E #x248F #x2490 #x2491 #x2492 #x2493 #x2494 #x2495 #x2496 #x2497 #x2498 #x2499 #x249A #x249B #x2474 #x2475 #x2476 #x2477 #x2478 #x2479 #x247A #x247B #x247C #x247D #x247E #x247F #x2480 #x2481 #x2482 #x2483 #x2484 #x2485 #x2486 #x2487 #x2460 #x2461 #x2462 #x2463 #x2464 #x2465 #x2466 #x2467 #x2468 #x2469 #xE76C #xE76D #x3220 #x3221 #x3222 #x3223 #x3224 #x3225 #x3226 #x3227 #x3228 #x3229 #xE76E #xE76F #x2160 #x2161 #x2162 #x2163 #x2164 #x2165 #x2166 #x2167 #x2168 #x2169 #x216A #x216B #xE770 #xE771 #xFF01 #xFF02 #xFF03 #xFFE5 #xFF05 #xFF06 #xFF07 #xFF08 #xFF09 #xFF0A #xFF0B #xFF0C #xFF0D #xFF0E #xFF0F #xFF10 #xFF11 #xFF12 #xFF13 #xFF14 #xFF15 #xFF16 #xFF17 #xFF18 #xFF19 #xFF1A #xFF1B #xFF1C #xFF1D #xFF1E #xFF1F #xFF20 #xFF21 #xFF22 #xFF23 #xFF24 #xFF25 #xFF26 #xFF27 #xFF28 #xFF29 #xFF2A #xFF2B #xFF2C #xFF2D #xFF2E #xFF2F #xFF30 #xFF31 #xFF32 #xFF33 #xFF34 #xFF35 #xFF36 #xFF37 #xFF38 #xFF39 #xFF3A #xFF3B #xFF3C #xFF3D #xFF3E #xFF3F #xFF40 #xFF41 #xFF42 #xFF43 #xFF44 #xFF45 #xFF46 #xFF47 #xFF48 #xFF49 #xFF4A #xFF4B #xFF4C #xFF4D #xFF4E #xFF4F #xFF50 #xFF51 #xFF52 #xFF53 #xFF54 #xFF55 #xFF56 #xFF57 #xFF58 #xFF59 #xFF5A #xFF5B #xFF5C #xFF5D #xFFE3 #x3041 #x3042 #x3043 #x3044 #x3045 #x3046 #x3047 #x3048 #x3049 #x304A #x304B #x304C #x304D #x304E #x304F #x3050 #x3051 #x3052 #x3053 #x3054 #x3055 #x3056 #x3057 #x3058 #x3059 #x305A #x305B #x305C #x305D #x305E #x305F #x3060 #x3061 #x3062 #x3063 #x3064 #x3065 #x3066 #x3067 #x3068 #x3069 #x306A #x306B #x306C #x306D #x306E #x306F #x3070 #x3071 #x3072 #x3073 #x3074 #x3075 #x3076 #x3077 #x3078 #x3079 #x307A #x307B #x307C #x307D #x307E #x307F #x3080 #x3081 #x3082 #x3083 #x3084 #x3085 #x3086 #x3087 #x3088 #x3089 #x308A #x308B #x308C #x308D #x308E #x308F #x3090 #x3091 #x3092 #x3093 #xE772 #xE773 #xE774 #xE775 #xE776 #xE777 #xE778 #xE779 #xE77A #xE77B #xE77C #x30A1 #x30A2 #x30A3 #x30A4 #x30A5 #x30A6 #x30A7 #x30A8 #x30A9 #x30AA #x30AB #x30AC #x30AD #x30AE #x30AF #x30B0 #x30B1 #x30B2 #x30B3 #x30B4 #x30B5 #x30B6 #x30B7 #x30B8 #x30B9 #x30BA #x30BB #x30BC #x30BD #x30BE #x30BF #x30C0 #x30C1 #x30C2 #x30C3 #x30C4 #x30C5 #x30C6 #x30C7 #x30C8 #x30C9 #x30CA #x30CB #x30CC #x30CD #x30CE #x30CF #x30D0 #x30D1 #x30D2 #x30D3 #x30D4 #x30D5 #x30D6 #x30D7 #x30D8 #x30D9 #x30DA #x30DB #x30DC #x30DD #x30DE #x30DF #x30E0 #x30E1 #x30E2 #x30E3 #x30E4 #x30E5 #x30E6 #x30E7 #x30E8 #x30E9 #x30EA #x30EB #x30EC #x30ED #x30EE #x30EF #x30F0 #x30F1 #x30F2 #x30F3 #x30F4 #x30F5 #x30F6 #xE77D #xE77E #xE77F #xE780 #xE781 #xE782 #xE783 #xE784 #x0391 #x0392 #x0393 #x0394 #x0395 #x0396 #x0397 #x0398 #x0399 #x039A #x039B #x039C #x039D #x039E #x039F #x03A0 #x03A1 #x03A3 #x03A4 #x03A5 #x03A6 #x03A7 #x03A8 #x03A9 #xE785 #xE786 #xE787 #xE788 #xE789 #xE78A #xE78B #xE78C #x03B1 #x03B2 #x03B3 #x03B4 #x03B5 #x03B6 #x03B7 #x03B8 #x03B9 #x03BA #x03BB #x03BC #x03BD #x03BE #x03BF #x03C0 #x03C1 #x03C3 #x03C4 #x03C5 #x03C6 #x03C7 #x03C8 #x03C9 #xE78D #xE78E #xE78F #xE790 #xE791 #xE792 #xE793 #xFE35 #xFE36 #xFE39 #xFE3A #xFE3F #xFE40 #xFE3D #xFE3E #xFE41 #xFE42 #xFE43 #xFE44 #xE794 #xE795 #xFE3B #xFE3C #xFE37 #xFE38 #xFE31 #xE796 #xFE33 #xFE34 #xE797 #xE798 #xE799 #xE79A #xE79B #xE79C #xE79D #xE79E #xE79F #x0410 #x0411 #x0412 #x0413 #x0414 #x0415 #x0401 #x0416 #x0417 #x0418 #x0419 #x041A #x041B #x041C #x041D #x041E #x041F #x0420 #x0421 #x0422 #x0423 #x0424 #x0425 #x0426 #x0427 #x0428 #x0429 #x042A #x042B #x042C #x042D #x042E #x042F #xE7A0 #xE7A1 #xE7A2 #xE7A3 #xE7A4 #xE7A5 #xE7A6 #xE7A7 #xE7A8 #xE7A9 #xE7AA #xE7AB #xE7AC #xE7AD #xE7AE #x0430 #x0431 #x0432 #x0433 #x0434 #x0435 #x0451 #x0436 #x0437 #x0438 #x0439 #x043A #x043B #x043C #x043D #x043E #x043F #x0440 #x0441 #x0442 #x0443 #x0444 #x0445 #x0446 #x0447 #x0448 #x0449 #x044A #x044B #x044C #x044D #x044E #x044F #xE7AF #xE7B0 #xE7B1 #xE7B2 #xE7B3 #xE7B4 #xE7B5 #xE7B6 #xE7B7 #xE7B8 #xE7B9 #xE7BA #xE7BB #x0101 #x00E1 #x01CE #x00E0 #x0113 #x00E9 #x011B #x00E8 #x012B #x00ED #x01D0 #x00EC #x014D #x00F3 #x01D2 #x00F2 #x016B #x00FA #x01D4 #x00F9 #x01D6 #x01D8 #x01DA #x01DC #x00FC #x00EA #x0251 #xE7C7 #x0144 #x0148 #xE7C8 #x0261 #xE7C9 #xE7CA #xE7CB #xE7CC #x3105 #x3106 #x3107 #x3108 #x3109 #x310A #x310B #x310C #x310D #x310E #x310F #x3110 #x3111 #x3112 #x3113 #x3114 #x3115 #x3116 #x3117 #x3118 #x3119 #x311A #x311B #x311C #x311D #x311E #x311F #x3120 #x3121 #x3122 #x3123 #x3124 #x3125 #x3126 #x3127 #x3128 #x3129 #xE7CD #xE7CE #xE7CF #xE7D0 #xE7D1 #xE7D2 #xE7D3 #xE7D4 #xE7D5 #xE7D6 #xE7D7 #xE7D8 #xE7D9 #xE7DA #xE7DB #xE7DC #xE7DD #xE7DE #xE7DF #xE7E0 #xE7E1 #xE7FE #xE7FF #xE800 #x2500 #x2501 #x2502 #x2503 #x2504 #x2505 #x2506 #x2507 #x2508 #x2509 #x250A #x250B #x250C #x250D #x250E #x250F #x2510 #x2511 #x2512 #x2513 #x2514 #x2515 #x2516 #x2517 #x2518 #x2519 #x251A #x251B #x251C #x251D #x251E #x251F #x2520 #x2521 #x2522 #x2523 #x2524 #x2525 #x2526 #x2527 #x2528 #x2529 #x252A #x252B #x252C #x252D #x252E #x252F #x2530 #x2531 #x2532 #x2533 #x2534 #x2535 #x2536 #x2537 #x2538 #x2539 #x253A #x253B #x253C #x253D #x253E #x253F #x2540 #x2541 #x2542 #x2543 #x2544 #x2545 #x2546 #x2547 #x2548 #x2549 #x254A #x254B #xE801 #xE802 #xE803 #xE804 #xE805 #xE806 #xE807 #xE808 #xE809 #xE80A #xE80B #xE80C #xE80D #xE80E #xE80F #x02CA #x02CB #x02D9 #x2013 #x2015 #x2025 #x2035 #x2105 #x2109 #x2196 #x2197 #x2198 #x2199 #x2215 #x221F #x2223 #x2252 #x2266 #x2267 #x22BF #x2550 #x2551 #x2552 #x2553 #x2554 #x2555 #x2556 #x2557 #x2558 #x2559 #x255A #x255B #x255C #x255D #x255E #x255F #x2560 #x2561 #x2562 #x2563 #x2564 #x2565 #x2566 #x2567 #x2568 #x2569 #x256A #x256B #x256C #x256D #x256E #x256F #x2570 #x2571 #x2572 #x2573 #x2581 #x2582 #x2583 #x2584 #x2585 #x2586 #x2587 #x2588 #x2589 #x258A #x258B #x258C #x258D #x258E #x258F #x2593 #x2594 #x2595 #x25BC #x25BD #x25E2 #x25E3 #x25E4 #x25E5 #x2609 #x2295 #x3012 #x301D #x301E #xE7BC #xE7BD #xE7BE #xE7BF #xE7C0 #xE7C1 #xE7C2 #xE7C3 #xE7C4 #xE7C5 #xE7C6 #x3021 #x3022 #x3023 #x3024 #x3025 #x3026 #x3027 #x3028 #x3029 #x32A3 #x338E #x338F #x339C #x339D #x339E #x33A1 #x33C4 #x33CE #x33D1 #x33D2 #x33D5 #xFE30 #xFFE2 #xFFE4 #xE7E2 #x2121 #x3231 #xE7E3 #x2010 #xE7E4 #xE7E5 #xE7E6 #x30FC #x309B #x309C #x30FD #x30FE #x3006 #x309D #x309E #xFE49 #xFE4A #xFE4B #xFE4C #xFE4D #xFE4E #xFE4F #xFE50 #xFE51 #xFE52 #xFE54 #xFE55 #xFE56 #xFE57 #xFE59 #xFE5A #xFE5B #xFE5C #xFE5D #xFE5E #xFE5F #xFE60 #xFE61 #xFE62 #xFE63 #xFE64 #xFE65 #xFE66 #xFE68 #xFE69 #xFE6A #xFE6B #xE7E7 #xE7E8 #xE7E9 #xE7EA #xE7EB #xE7EC #xE7ED #xE7EE #xE7EF #xE7F0 #xE7F1 #xE7F2 #xE7F3 #x3007 #xE7F4 #xE7F5 #xE7F6 #xE7F7 #xE7F8 #xE7F9 #xE7FA #xE7FB #xE7FC #xE7FD #x0020)))

Common Lisp

.lisp

cac-t-u-s/om-sharp

GPL-3.0

9/19/2024, 11:25:22 AM (Europe/Amsterdam)

9b2c238b38660680dd953edb0d6137466e9cc20b755d564258a744e657d72db1

strings.lisp

cac-t-u-s_om-sharp/src/api/foreign-interface/ffi/babel/src/strings.lisp

;;;; -*- Mode: lisp; indent-tabs-mode: nil -*- ;;; ;;; strings.lisp --- Conversions between strings and UB8 vectors. ;;; ;;; Copyright (C) 2007, Luis Oliveira <[email protected]> ;;; ;;; Permission is hereby granted, free of charge, to any person ;;; obtaining a copy of this software and associated documentation ;;; files (the "Software"), to deal in the Software without ;;; restriction, including without limitation the rights to use, copy, ;;; modify, merge, publish, distribute, sublicense, and/or sell copies ;;; of the Software, and to permit persons to whom the Software is ;;; furnished to do so, subject to the following conditions: ;;; ;;; The above copyright notice and this permission notice shall be ;;; included in all copies or substantial portions of the Software. ;;; ;;; THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, ;;; EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF ;;; MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND ;;; NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT ;;; HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, ;;; WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, ;;; OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER ;;; DEALINGS IN THE SOFTWARE. (in-package #:babel) ;;; The usefulness of this string/octets interface of Babel's is very ;;; limited on Lisps with 8-bit characters which will in effect only ;;; support the latin-1 subset of Unicode. That is, all encodings are ;;; supported but we can only store the first 256 code points in Lisp ;;; strings. Support for using other 8-bit encodings for strings on ;;; these Lisps could be added with an extra encoding/decoding step. ;;; Supporting other encodings with larger code units would be silly ;;; (it would break expectations about common string operations) and ;;; better done with something like Closure's runes. ;;; Can we handle unicode fully? (eval-when (:compile-toplevel :load-toplevel :execute) ;; The EVAL is just here to avoid warnings... (case (eval char-code-limit) (#x100 (pushnew '8-bit-chars *features*)) (#x10000 (pushnew 'ucs-2-chars *features*)) (#x110000 #| yay |#) ;; This is here mostly because if the CHAR-CODE-LIMIT is bigger ;; than #x11000, strange things might happen but we probably ;; shouldn't descriminate against other, smaller, values. (t (error "Strange CHAR-CODE-LIMIT (#x~X), bailing out." char-code-limit)))) ;;; Adapted from Ironclad. TODO: check if it's worthwhile adding ;;; implementation-specific accessors such as SAP-REF-* for SBCL. (defmacro ub-get (vector index &optional (bytes 1) (endianness :ne)) (let ((big-endian (member endianness '(:be #+big-endian :ne #+little-endian :re)))) (once-only (vector index) `(logand ,(1- (ash 1 (* 8 bytes))) (logior ,@(loop for i from 0 below bytes for offset = (if big-endian i (- bytes i 1)) for shift = (if big-endian (* (- bytes i 1) 8) (* offset 8)) collect `(ash (aref ,vector (+ ,index ,offset)) ,shift))))))) (defmacro ub-set (value vector index &optional (bytes 1) (endianness :ne)) (let ((big-endian (member endianness '(:be #+big-endian :ne #+little-endian :re)))) `(progn ,@(loop for i from 1 to bytes for offset = (if big-endian (- bytes i) (1- i)) collect `(setf (aref ,vector (+ ,index ,offset)) (ldb (byte 8 ,(* 8 (1- i))) ,value))) (values)))) (defmacro string-get (string index) `(char-code (schar ,string ,index))) (defmacro string-set (code string index) `(setf (schar ,string ,index) (code-char ,code))) ;;; SIMPLE-BASE-STRING would also be a subtype of SIMPLE-STRING so we ;;; don't use that because on SBCL BASE-CHARs can only hold ASCII. ;;; Also, with (> SPEED SAFETY) (setf (schar base-str n) big-char) ;;; will quietly work, sort of. ;;; ;;; XXX: test this on various lisps. (defconstant unicode-char-code-limit char-code-limit "An alias for CL:CHAR-CODE-LIMIT which might be lower than #x110000 on some Lisps.") (deftype unicode-char () "This character type can hold any characters whose CHAR-CODEs are less than UNICODE-CHAR-CODE-LIMIT." #+lispworks 'lw:simple-char #-lispworks 'character) (deftype simple-unicode-string () "Alias for (SIMPLE-ARRAY UNICODE-CHAR (*))." '(simple-array unicode-char (*))) (deftype unicode-string () "Alias for (VECTOR UNICODE-CHAR *)." '(vector unicode-char *)) (defparameter *string-vector-mappings* (instantiate-concrete-mappings ;; :optimize ((speed 3) (safety 0) (debug 0) (compilation-speed 0)) :octet-seq-setter ub-set :octet-seq-getter ub-get :octet-seq-type (simple-array (unsigned-byte 8) (*)) :code-point-seq-setter string-set :code-point-seq-getter string-get :code-point-seq-type simple-unicode-string)) #+sbcl (defparameter *simple-base-string-vector-mappings* (instantiate-concrete-mappings ;; :optimize ((speed 3) (safety 0) (debug 0) (compilation-speed 0)) :instantiate-decoders nil :octet-seq-setter ub-set :octet-seq-getter ub-get :octet-seq-type (simple-array (unsigned-byte 8) (*)) :code-point-seq-setter string-set :code-point-seq-getter string-get :code-point-seq-type simple-base-string)) ;;; Do we want a more a specific error condition here? (defun check-vector-bounds (vector start end) (unless (<= 0 start end (length vector)) (error "Invalid start (~A) and end (~A) values for vector of length ~A." start end (length vector)))) (defmacro with-simple-vector (((v vector) (s start) (e end)) &body body) "If VECTOR is a displaced or adjustable array, binds V to the underlying simple vector, adds an adequate offset to START and END and binds those offset values to S and E. Otherwise, if VECTOR is already a simple array, it's simply bound to V with no further changes. START and END are unchecked and assumed to be within bounds. Note that in some Lisps, a slow copying implementation is necessary to obtain a simple vector thus V will be bound to a copy of VECTOR coerced to a simple-vector. Therefore, you shouldn't attempt to modify V." #+sbcl `(sb-kernel:with-array-data ((,v ,vector) (,s ,start) (,e ,end)) ,@body) #+(or cmu scl) `(lisp::with-array-data ((,v ,vector) (,s ,start) (,e ,end)) ,@body) #+openmcl (with-unique-names (offset) `(multiple-value-bind (,v ,offset) (ccl::array-data-and-offset ,vector) (let ((,s (+ ,start ,offset)) (,e (+ ,end ,offset))) ,@body))) #+allegro (with-unique-names (offset) `(excl::with-underlying-simple-vector (,vector ,v ,offset) (let ((,e (+ ,end ,offset)) (,s (+ ,start ,offset))) ,@body))) ;; slow, copying implementation #-(or sbcl cmu scl openmcl allegro) (once-only (vector) `(funcall (if (adjustable-array-p ,vector) #'call-with-array-data/copy #'call-with-array-data/fast) ,vector ,start ,end (lambda (,v ,s ,e) ,@body)))) #-(or sbcl cmu scl openmcl allegro) (progn ;; Stolen from f2cl. (defun array-data-and-offset (array) (loop with offset = 0 do (multiple-value-bind (displaced-to index-offset) (array-displacement array) (when (null displaced-to) (return-from array-data-and-offset (values array offset))) (incf offset index-offset) (setf array displaced-to)))) (defun call-with-array-data/fast (vector start end fn) (multiple-value-bind (data offset) (array-data-and-offset vector) (funcall fn data (+ offset start) (+ offset end)))) (defun call-with-array-data/copy (vector start end fn) (funcall fn (replace (make-array (- end start) :element-type (array-element-type vector)) vector :start2 start :end2 end) 0 (- end start)))) (defmacro with-checked-simple-vector (((v vector) (s start) (e end)) &body body) "Like WITH-SIMPLE-VECTOR but bound-checks START and END." (once-only (vector start) `(let ((,e (or ,end (length ,vector)))) (check-vector-bounds ,vector ,start ,e) (with-simple-vector ((,v ,vector) (,s ,start) (,e ,e)) ,@body)))) ;;; Future features these functions should have: ;;; ;;; * null-terminate ;;; * specify target vector/string + offset ;;; * documentation :) (declaim (inline octets-to-string string-to-octets string-size-in-octets vector-size-in-chars concatenate-strings-to-octets bom-vector)) (defun octets-to-string (vector &key (start 0) end (errorp (not *suppress-character-coding-errors*)) (encoding *default-character-encoding*)) (check-type vector (vector (unsigned-byte 8))) (with-checked-simple-vector ((vector vector) (start start) (end end)) (declare (type (simple-array (unsigned-byte 8) (*)) vector)) (let ((*suppress-character-coding-errors* (not errorp)) (mapping (lookup-mapping *string-vector-mappings* encoding))) (multiple-value-bind (size new-end) (funcall (code-point-counter mapping) vector start end -1) ;; TODO we could optimize ASCII here: the result should ;; be a simple-base-string filled using code-char... (let ((string (make-string size :element-type 'unicode-char))) (funcall (decoder mapping) vector start new-end string 0) string))))) (defun bom-vector (encoding use-bom) (check-type use-bom (member :default t nil)) (the simple-vector (if (null use-bom) #() (let ((enc (typecase encoding (external-format (external-format-encoding encoding)) (t (get-character-encoding encoding))))) (if (or (eq use-bom t) (and (eq use-bom :default) (enc-use-bom enc))) ;; VALUES avoids a "type assertion too complex to check" note. (values (enc-bom-encoding enc)) #()))))) (defun string-to-octets (string &key (encoding *default-character-encoding*) (start 0) end (use-bom :default) (errorp (not *suppress-character-coding-errors*))) (declare (optimize (speed 3) (safety 2))) (let ((*suppress-character-coding-errors* (not errorp))) (etypecase string ;; On some lisps (e.g. clisp and ccl) all strings are BASE-STRING and all ;; characters are BASE-CHAR. So, only enable this optimization for ;; selected targets. #+sbcl (simple-base-string (unless end (setf end (length string))) (check-vector-bounds string start end) (let* ((mapping (lookup-mapping *simple-base-string-vector-mappings* encoding)) (bom (bom-vector encoding use-bom)) (bom-length (length bom)) ;; OPTIMIZE: we could use the (length string) information here ;; because it's a simple-base-string where each character <= 127 (result (make-array (+ (the array-index (funcall (the function (octet-counter mapping)) string start end -1)) bom-length) :element-type '(unsigned-byte 8)))) (replace result bom) (funcall (the function (encoder mapping)) string start end result bom-length) result)) (string ;; FIXME: we shouldn't really need that coercion to UNICODE-STRING ;; but we kind of because it's declared all over. To avoid that, ;; we'd need different types for input and output strings. Or maybe ;; this is not a problem; figure that out. (with-checked-simple-vector ((string (coerce string 'unicode-string)) (start start) (end end)) (declare (type simple-unicode-string string)) (let* ((mapping (lookup-mapping *string-vector-mappings* encoding)) (bom (bom-vector encoding use-bom)) (bom-length (length bom)) (result (make-array (+ (the array-index (funcall (the function (octet-counter mapping)) string start end -1)) bom-length) :element-type '(unsigned-byte 8)))) (replace result bom) (funcall (the function (encoder mapping)) string start end result bom-length) result)))))) (defun concatenate-strings-to-octets (encoding &rest strings) "Optimized equivalent of \(string-to-octets \(apply #'concatenate 'string strings) :encoding encoding)" (declare (dynamic-extent strings)) (let* ((mapping (lookup-mapping *string-vector-mappings* encoding)) (octet-counter (octet-counter mapping)) (vector (make-array (the array-index (reduce #'+ strings :key (lambda (string) (funcall octet-counter string 0 (length string) -1)))) :element-type '(unsigned-byte 8))) (current-index 0)) (declare (type array-index current-index)) (dolist (string strings) (check-type string string) (with-checked-simple-vector ((string (coerce string 'unicode-string)) (start 0) (end (length string))) (declare (type simple-unicode-string string)) (incf current-index (funcall (encoder mapping) string start end vector current-index)))) vector)) (defun string-size-in-octets (string &key (start 0) end (max -1 maxp) (errorp (not *suppress-character-coding-errors*)) (encoding *default-character-encoding*)) (check-type string string) (with-checked-simple-vector ((string (coerce string 'unicode-string)) (start start) (end end)) (declare (type simple-unicode-string string)) (let ((mapping (lookup-mapping *string-vector-mappings* encoding)) (*suppress-character-coding-errors* (not errorp))) (when maxp (assert (plusp max))) (funcall (octet-counter mapping) string start end max)))) (defun vector-size-in-chars (vector &key (start 0) end (max -1 maxp) (errorp (not *suppress-character-coding-errors*)) (encoding *default-character-encoding*)) (check-type vector (vector (unsigned-byte 8))) (with-checked-simple-vector ((vector vector) (start start) (end end)) (declare (type (simple-array (unsigned-byte 8) (*)) vector)) (let ((mapping (lookup-mapping *string-vector-mappings* encoding)) (*suppress-character-coding-errors* (not errorp))) (when maxp (assert (plusp max))) (funcall (code-point-counter mapping) vector start end max)))) (declaim (notinline octets-to-string string-to-octets string-size-in-octets vector-size-in-chars concatenate-strings-to-octets))

Common Lisp

.lisp

cac-t-u-s/om-sharp

GPL-3.0

9/19/2024, 11:25:22 AM (Europe/Amsterdam)

f261eaa8cd51476fe55bfb634a653f0b6b753bb714c89823755bf7e6a6456279

enc-cp1251.lisp

cac-t-u-s_om-sharp/src/api/foreign-interface/ffi/babel/src/enc-cp1251.lisp

;;;; -*- Mode: lisp; indent-tabs-mode: nil -*- ;;; ;;; enc-cp1251.lisp --- Implementation of the CP1251 character encoding. ;;; ;;; Copyright (C) 2009, Andrey Moskvitin ;;; ;;; Permission is hereby granted, free of charge, to any person ;;; obtaining a copy of this software and associated documentation ;;; files (the "Software"), to deal in the Software without ;;; restriction, including without limitation the rights to use, copy, ;;; modify, merge, publish, distribute, sublicense, and/or sell copies ;;; of the Software, and to permit persons to whom the Software is ;;; furnished to do so, subject to the following conditions: ;;; ;;; The above copyright notice and this permission notice shall be ;;; included in all copies or substantial portions of the Software. ;;; ;;; THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, ;;; EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF ;;; MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND ;;; NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT ;;; HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, ;;; WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, ;;; OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER ;;; DEALINGS IN THE SOFTWARE. (in-package #:babel-encodings) (define-character-encoding :cp1251 "An 8-bit, fixed-width character Russian encoding from Windows." :aliases '(:windows-1251) :literal-char-code-limit #x80) (define-constant +cp1251-to-unicode+ #(;; #x80 #x0402 #x0403 #x201a #x0453 #x201e #x2026 #x2020 #x2021 #x20ac #x2030 #x0409 #x2039 #x040a #x040c #x040b #x040f ;; #x90 #x0452 #x2018 #x2019 #x201c #x201d #x2022 #x2013 #x2014 #xfffd #x2122 #x0459 #x203a #x045a #x045c #x045b #x045f ;; #xa0 #x00a0 #x040e #x045e #x0408 #x00a4 #x0490 #x00a6 #x00a7 #x0401 #x00a9 #x0404 #x00ab #x00ac #x00ad #x00ae #x0407 ;; #xb0 #x00b0 #x00b1 #x0406 #x0456 #x0491 #x00b5 #x00b6 #x00b7 #x0451 #x2116 #x0454 #x00bb #x0458 #x0405 #x0455 #x0457 ;; #xc0 #x0410 #x0411 #x0412 #x0413 #x0414 #x0415 #x0416 #x0417 #x0418 #x0419 #x041a #x041b #x041c #x041d #x041e #x041f ;; #xd0 #x0420 #x0421 #x0422 #x0423 #x0424 #x0425 #x0426 #x0427 #x0428 #x0429 #x042a #x042b #x042c #x042d #x042e #x042f ;; #xe0 #x0430 #x0431 #x0432 #x0433 #x0434 #x0435 #x0436 #x0437 #x0438 #x0439 #x043a #x043b #x043c #x043d #x043e #x043f ;; #xf0 #x0440 #x0441 #x0442 #x0443 #x0444 #x0445 #x0446 #x0447 #x0448 #x0449 #x044a #x044b #x044c #x044d #x044e #x044f) :test #'equalp) (define-unibyte-decoder :cp1251 (octet) (if (< octet #x80) octet (svref +cp1251-to-unicode+ (the ub8 (- octet #x80))))) (define-constant +unicode-a0-bf-to-cp1251+ #(#xa0 #x00 #x00 #x00 #xa4 #x00 #xa6 #xa7 ; #xa0-#xa7 #x00 #xa9 #x00 #xab #xac #xad #xae #x00 ; #xa8-#xaf #xb0 #xb1 #x00 #x00 #x00 #xb5 #xb6 #xb7 ; #xb0-#xb7 #x00 #x00 #x00 #xbb #x00 #x00 #x00 #x00) ; #xb8-#xbf :test #'equalp) (define-constant +unicode-0-97-to-cp1251+ #(#x00 #xa8 #x80 #x81 #xaa #xbd #xb2 #xaf ; #x00-#x07 #xa3 #x8a #x8c #x8e #x8d #x00 #xa1 #x8f ; #x08-#x0f #xc0 #xc1 #xc2 #xc3 #xc4 #xc5 #xc6 #xc7 ; #x10-#x17 #xc8 #xc9 #xca #xcb #xcc #xcd #xce #xcf ; #x18-#x1f #xd0 #xd1 #xd2 #xd3 #xd4 #xd5 #xd6 #xd7 ; #x20-#x27 #xd8 #xd9 #xda #xdb #xdc #xdd #xde #xdf ; #x28-#x2f #xe0 #xe1 #xe2 #xe3 #xe4 #xe5 #xe6 #xe7 ; #x30-#x37 #xe8 #xe9 #xea #xeb #xec #xed #xee #xef ; #x38-#x3f #xf0 #xf1 #xf2 #xf3 #xf4 #xf5 #xf6 #xf7 ; #x40-#x47 #xf8 #xf9 #xfa #xfb #xfc #xfd #xfe #xff ; #x48-#x4f #x00 #xb8 #x90 #x83 #xba #xbe #xb3 #xbf ; #x50-#x57 #xbc #x9a #x9c #x9e #x9d #x00 #xa2 #x9f ; #x58-#x5f #x00 #x00 #x00 #x00 #x00 #x00 #x00 #x00 ; #x60-#x67 #x00 #x00 #x00 #x00 #x00 #x00 #x00 #x00 ; #x68-#x6f #x00 #x00 #x00 #x00 #x00 #x00 #x00 #x00 ; #x70-#x77 #x00 #x00 #x00 #x00 #x00 #x00 #x00 #x00 ; #x78-#x7f #x00 #x00 #x00 #x00 #x00 #x00 #x00 #x00 ; #x80-#x87 #x00 #x00 #x00 #x00 #x00 #x00 #x00 #x00 ; #x88-#x8f #xa5 #xb4 #x00 #x00 #x00 #x00 #x00 #x00) ; #x90-#x97 :test #'equalp) (define-constant +unicode-10-3f-to-cp1251+ #(#x00 #x00 #x00 #x96 #x97 #x00 #x00 #x00 ; #x10-#x17 #x91 #x92 #x82 #x00 #x93 #x94 #x84 #x00 ; #x18-#x1f #x86 #x87 #x95 #x00 #x00 #x00 #x85 #x00 ; #x20-#x27 #x00 #x00 #x00 #x00 #x00 #x00 #x00 #x00 ; #x28-#x2f #x89 #x00 #x00 #x00 #x00 #x00 #x00 #x00 ; #x30-#x37 #x00 #x8b #x9b #x00 #x00 #x00 #x00 #x00) ; #x38-#x3f :test #'equalp) (define-unibyte-encoder :cp1251 (code) (cond ((< code #x80) code) ((and (>= code #xa0) (< code #xc0)) (svref +unicode-a0-bf-to-cp1251+ (the ub8 (- code #xa0)))) ((and (>= code #x400) (< code #x498)) (svref +unicode-0-97-to-cp1251+ (the ub8 (- code #x400)))) ((and (>= code #x2010) (< code #x2040)) (svref +unicode-10-3f-to-cp1251+ (the ub8 (- code #x2010)))) ((= code #x20ac) #x88) ((= code #x2116) #xb9) ((= code #x2122) #x99) (t (handle-error))))

Common Lisp

.lisp

cac-t-u-s/om-sharp

GPL-3.0

9/19/2024, 11:25:22 AM (Europe/Amsterdam)

ecec6d5e208cdffb11a2f5029b4fdafcc794e145a7f6553bce8389b13aa91418

enc-cp1252.lisp

cac-t-u-s_om-sharp/src/api/foreign-interface/ffi/babel/src/enc-cp1252.lisp

;;;; -*- Mode: lisp; indent-tabs-mode: nil -*- ;;; ;;; enc-cp1252.lisp --- Implementation of the CP1252 character encoding. ;;; ;;; Copyright (C) 2011, Nicolas Martyanoff ;;; ;;; Permission is hereby granted, free of charge, to any person ;;; obtaining a copy of this software and associated documentation ;;; files (the "Software"), to deal in the Software without ;;; restriction, including without limitation the rights to use, copy, ;;; modify, merge, publish, distribute, sublicense, and/or sell copies ;;; of the Software, and to permit persons to whom the Software is ;;; furnished to do so, subject to the following conditions: ;;; ;;; The above copyright notice and this permission notice shall be ;;; included in all copies or substantial portions of the Software. ;;; ;;; THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, ;;; EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF ;;; MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND ;;; NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT ;;; HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, ;;; WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, ;;; OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER ;;; DEALINGS IN THE SOFTWARE. (in-package #:babel-encodings) (define-character-encoding :cp1252 "A 8-bit, fixed-width character encoding used by Windows for Western European languages." :aliases '(:windows-1252) :literal-char-code-limit 256) (define-constant +cp1252-to-unicode+ #(#x20ac nil #x201a #x0192 #x201e #x2026 #x2020 #x2021 #x02c6 #x2030 #x0160 #x2039 #x0152 nil #x017d nil nil #x2018 #x2019 #x201c #x201d #x2022 #x2013 #x2014 #x02dc #x2122 #x0161 #x203a #x0153 nil #x017e #x0178) :test #'equalp) (define-unibyte-decoder :cp1252 (octet) (if (and (>= octet #x80) (<= octet #x9f)) (svref +cp1252-to-unicode+ (the ub8 (- octet #x80))) octet)) (define-constant +unicode-0152-017e-cp1252+ #(#x8c #x9c #x00 #x00 #x00 #x00 #x00 #x00 #x00 #x00 #x00 #x00 #x00 #x00 #x8a #x9a #x00 #x00 #x00 #x00 #x00 #x00 #x00 #x00 #x00 #x00 #x00 #x00 #x00 #x00 #x00 #x00 #x00 #x00 #x00 #x00 #x00 #x00 #x9f #x00 #x00 #x00 #x00 #x8e #x9e) :test #'equalp) (define-constant +unicode-2013-203a-cp1252+ #(#x96 #x97 #x00 #x00 #x00 #x91 #x92 #x82 #x00 #x93 #x94 #x84 #x00 #x86 #x87 #x95 #x00 #x00 #x00 #x85 #x00 #x00 #x00 #x00 #x00 #x00 #x00 #x00 #x00 #x89 #x00 #x00 #x00 #x00 #x00 #x00 #x00 #x00 #x8b #x9b) :test #'equalp) (define-unibyte-encoder :cp1252 (code) (cond ((or (< code #x80) (and (> code #xa0) (<= code #xff))) code) ((and (>= code #x0152) (<= code #x017e)) (svref +unicode-0152-017e-cp1252+ (the ub8 (- code #x0152)))) ((= code #x0192) #x83) ((= code #x02c6) #x88) ((= code #x02dc) #x89) ((and (>= code #x2013) (<= code #x203a)) (svref +unicode-2013-203a-cp1252+ (the ub8 (- code #x2013)))) ((= code #x20ac) #x80) ((= code #x2122) #x99) (t (handle-error))))

Common Lisp

.lisp

cac-t-u-s/om-sharp

GPL-3.0

9/19/2024, 11:25:22 AM (Europe/Amsterdam)

17e5c5dd531a45787008a5682a982ef3865d5a9eb39bd8ac250943fb59b39f35

enc-ebcdic.lisp

cac-t-u-s_om-sharp/src/api/foreign-interface/ffi/babel/src/enc-ebcdic.lisp

;;;; -*- Mode: lisp; indent-tabs-mode: nil -*- ;;; ;;; enc-ebcdic.lisp --- EBCDIC encodings. ;;; ;;; Copyright (C) 2007, Luis Oliveira <[email protected]> ;;; ;;; Permission is hereby granted, free of charge, to any person ;;; obtaining a copy of this software and associated documentation ;;; files (the "Software"), to deal in the Software without ;;; restriction, including without limitation the rights to use, copy, ;;; modify, merge, publish, distribute, sublicense, and/or sell copies ;;; of the Software, and to permit persons to whom the Software is ;;; furnished to do so, subject to the following conditions: ;;; ;;; The above copyright notice and this permission notice shall be ;;; included in all copies or substantial portions of the Software. ;;; ;;; THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, ;;; EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF ;;; MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND ;;; NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT ;;; HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, ;;; WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, ;;; OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER ;;; DEALINGS IN THE SOFTWARE. (in-package #:babel-encodings) (define-character-encoding :ebcdic-us "An alleged character set used on IBM dinosaurs." :aliases '(:ibm-037)) (define-constant +ebcdic-decode-table+ (make-array 256 :element-type 'ub8 :initial-contents '(#x00 #x01 #x02 #x03 #x9c #x09 #x86 #x7f #x97 #x8d #x8e #x0b #x0c #x0d #x0e #x0f #x10 #x11 #x12 #x13 #x9d #x85 #x08 #x87 #x18 #x19 #x92 #x8f #x1c #x1d #x1e #x1f #x80 #x81 #x82 #x83 #x84 #x0a #x17 #x1b #x88 #x89 #x8a #x8b #x8c #x05 #x06 #x07 #x90 #x91 #x16 #x93 #x94 #x95 #x96 #x04 #x98 #x99 #x9a #x9b #x14 #x15 #x9e #x1a #x20 #xa0 #xe2 #xe4 #xe0 #xe1 #xe3 #xe5 #xe7 #xf1 #xa2 #x2e #x3c #x28 #x2b #x7c #x26 #xe9 #xea #xeb #xe8 #xed #xee #xef #xec #xdf #x21 #x24 #x2a #x29 #x3b #xac #x2d #x2f #xc2 #xc4 #xc0 #xc1 #xc3 #xc5 #xc7 #xd1 #xa6 #x2c #x25 #x5f #x3e #x3f #xf8 #xc9 #xca #xcb #xc8 #xcd #xce #xcf #xcc #x60 #x3a #x23 #x40 #x27 #x3d #x22 #xd8 #x61 #x62 #x63 #x64 #x65 #x66 #x67 #x68 #x69 #xab #xbb #xf0 #xfd #xfe #xb1 #xb0 #x6a #x6b #x6c #x6d #x6e #x6f #x70 #x71 #x72 #xaa #xba #xe6 #xb8 #xc6 #xa4 #xb5 #x7e #x73 #x74 #x75 #x76 #x77 #x78 #x79 #x7a #xa1 #xbf #xd0 #xdd #xde #xae #x5e #xa3 #xa5 #xb7 #xa9 #xa7 #xb6 #xbc #xbd #xbe #x5b #x5d #xaf #xa8 #xb4 #xd7 #x7b #x41 #x42 #x43 #x44 #x45 #x46 #x47 #x48 #x49 #xad #xf4 #xf6 #xf2 #xf3 #xf5 #x7d #x4a #x4b #x4c #x4d #x4e #x4f #x50 #x51 #x52 #xb9 #xfb #xfc #xf9 #xfa #xff #x5c #xf7 #x53 #x54 #x55 #x56 #x57 #x58 #x59 #x5a #xb2 #xd4 #xd6 #xd2 #xd3 #xd5 #x30 #x31 #x32 #x33 #x34 #x35 #x36 #x37 #x38 #x39 #xb3 #xdb #xdc #xd9 #xda #x9f)) :test #'equalp) (define-constant +ebcdic-encode-table+ (loop with rt = (make-array 256 :element-type 'ub8 :initial-element 0) for code across +ebcdic-decode-table+ for i from 0 do (assert (= 0 (aref rt code))) (setf (aref rt code) i) finally (return rt)) :test #'equalp) (define-unibyte-encoder :ebcdic-us (code) (if (>= code 256) (handle-error) (aref +ebcdic-encode-table+ code))) (define-unibyte-decoder :ebcdic-us (octet) (aref +ebcdic-decode-table+ octet))

Common Lisp

.lisp

cac-t-u-s/om-sharp

GPL-3.0

9/19/2024, 11:25:22 AM (Europe/Amsterdam)

6017354fefc6457ca8d2dc2e1d07173f70017999b2fdbfed4fa3b4341e8c645f

enc-gbk.lisp

cac-t-u-s_om-sharp/src/api/foreign-interface/ffi/babel/src/enc-gbk.lisp

;;;; -*- Mode: lisp; indent-tabs-mode: nil -*- ;;; ;;; enc-gbk.lisp --- GBK encodings. ;;; ;;; Copyright (C) 2011, Li Wenpeng <[email protected]> ;;; ;;; Permission is hereby granted, free of charge, to any person ;;; obtaining a copy of this software and associated documentation ;;; files (the "Software"), to deal in the Software without ;;; restriction, including without limitation the rights to use, copy, ;;; modify, merge, publish, distribute, sublicense, and/or sell copies ;;; of the Software, and to permit persons to whom the Software is ;;; furnished to do so, subject to the following conditions: ;;; ;;; The above copyright notice and this permission notice shall be ;;; included in all copies or substantial portions of the Software. ;;; ;;; THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, ;;; EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF ;;; MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND ;;; NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT ;;; HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, ;;; WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, ;;; OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER ;;; DEALINGS IN THE SOFTWARE. (in-package #:babel-encodings) ;; populated in gbk-map.lisp (defvar *gbk-unicode-mapping*) (defconstant +gbk2-offset+ 0) (defconstant +gbk3-offset+ 6763) (defconstant +gbk4-offset+ (+ 6763 6080)) (defconstant +gbk1-offset+ 20902) (defconstant +gbk5-offset+ (+ 20902 846)) (define-character-encoding :gbk "GBK is an extension of the GB2312 character set for simplified Chinese characters, used in the People's Republic of China." :max-units-per-char 4 :literal-char-code-limit #x80) (define-condition invalid-gbk-byte (character-decoding-error) () (:documentation "Signalled when an invalid GBK byte is found.")) (define-condition invalid-gbk-character (character-decoding-error) () (:documentation "Signalled when an invalid GBK character is found.")) (define-octet-counter :gbk (getter type) `(lambda (seq start end max) (declare (type ,type seq) (fixnum start end max)) (let ((noctets 0)) (loop for i from start below end for u1 of-type code-point = (,getter seq i) do (cond ((< u1 #x80) (incf noctets)) (t (incf noctets 2))) (when (and (plusp max) (= noctets max)) (return (values noctets i))) finally (return (values noctets i)))))) (define-code-point-counter :gbk (getter type) `(lambda (seq start end max) (declare (type ,type seq)) (let (u1 (noctets 0)) (loop with i = start while (< i end) do (setf u1 (,getter seq i)) (cond ((eq 0 (logand u1 #x80)) (incf i)) (t (incf i 2))) (incf noctets) (when (and (plusp max) (= noctets max)) (return (values noctets i))) finally (return (values noctets i)))))) (define-encoder :gbk (getter src-type setter dest-type) `(lambda (src start end dest d-start) (declare (type ,src-type src) (type ,dest-type dest) (fixnum start end d-start)) (macrolet ((do-encoding (index) `(let ((u1 0) (u2 0)) (cond ((<= +gbk2-offset+ ,index (- +gbk3-offset+ 1)) ; gbk/2 (setf u1 (+ #xB0 (truncate (/ ,index 94)))) (setf u2 (+ #xA1 (mod ,index 94)))) ((<= +gbk3-offset+ ,index (- +gbk4-offset+ 1)) ; gbk/3 (setf index (- ,index +gbk3-offset+)) (setf u1 (+ #x81 (truncate (/ ,index 190)))) (setf u2 (+ #x40 (mod ,index 190))) (if (>= u2 #x7F) (incf u2))) ((<= +gbk4-offset+ ,index (- +gbk1-offset+ 1)) ; gbk/4 (setf index (- ,index +gbk4-offset+)) (setf u1 (+ #xAA (truncate (/ ,index 96)))) (setf u2 (+ #x40 (mod ,index 96))) (if (>= u2 #x7F) (incf u2))) ((<= +gbk1-offset+ ,index (- +gbk5-offset+ 1)) ; gbk/1 (setf index (- ,index +gbk1-offset+)) (setf u1 (+ #xA1 (truncate (/ ,index 94)))) (setf u2 (+ #xA1 (mod ,index 94)))) ((<= +gbk5-offset+ ,index (length *gbk-unicode-mapping*)) ; gbk/5 (setf index (- ,index +gbk5-offset+)) (setf u1 (+ #xA8 (truncate (/ ,index 96)))) (setf u2 (+ #x40 (mod ,index 96))) (if (>= u2 #x7F) (incf u2)))) (values u1 u2)))) (let ((c 0) index (noctets 0)) (loop for i from start below end for code of-type code-point = (,getter src i) do (macrolet ((handle-error (&optional (c 'character-encoding-error)) `(encoding-error code :gbk src i +repl+ ',c))) (setf c (code-char code)) (cond ((< code #x80) ; ascii (,setter code dest noctets) (incf noctets)) (t ; gbk (setf index (position c *gbk-unicode-mapping*)) (if (not index) (handle-error invalid-gbk-character)) (multiple-value-bind (uh ul) (do-encoding index) (,setter uh dest noctets) (,setter ul dest (+ 1 noctets)) (incf noctets 2))))) finally (return (the fixnum (- noctets d-start)))))))) (define-decoder :gbk (getter src-type setter dest-type) `(lambda (src start end dest d-start) (declare (type ,src-type src) (type ,dest-type dest)) (let ((u1 0) (u2 0) (index 0) (tmp 0) (noctets 0)) (loop with i = start while (< i end) do (macrolet ((handle-error (&optional (c 'character-decoding-error)) `(decoding-error #(u1 u2) :gbk src i +repl+ ',c))) (setf u1 (,getter src i)) (incf i) (cond ((eq 0 (logand u1 #x80)) (,setter u1 dest noctets)) (t (setf u2 (,getter src i)) (incf i) (setf index (block setter-block (cond ((and (<= #xB0 u1 #xF7) (<= #xA1 u2 #xFE)) (+ +gbk2-offset+ (+ (* 94 (- u1 #xB0)) (- u2 #xA1)))) ((and (<= #x81 u1 #xA0) (<= #x40 u2 #xFE)) (cond ((> u2 #x7F) (setf tmp 1)) (t (setf tmp 0))) (+ +gbk3-offset+ (* 190 (- u1 #x81)) (- u2 #x40 tmp))) ((and (<= #xAA u1 #xFE) (<= #x40 #xA0)) (cond ((> u2 #x7F) (setf tmp 1)) (t (setf tmp 0))) (+ +gbk4-offset+ (* 96 (- u1 #xAA)) (- u2 #x40 tmp))) ((and (<= #xA1 u1 #xA9) (<= #xA1 u2 #xFE)) (+ +gbk1-offset+ (* 94 (- u1 #xA1)) (- u2 #xA1))) ((and (<= #xA8 u1 #xA9) (<= #x40 #xA0)) (cond ((> u2 #x7F) (setf tmp 1)) (t (setf tmp 0))) (+ +gbk5-offset+ (* 96 (- u1 #xA8)) (- u2 #x40 tmp))) (t (handle-error invalid-gbk-byte))))) (when (>= index (length *gbk-unicode-mapping*)) (handle-error invalid-gbk-byte)) (,setter (char-code (elt *gbk-unicode-mapping* index)) dest noctets))) (incf noctets)) finally (return (the fixnum (- noctets d-start)))))))

Common Lisp

.lisp

cac-t-u-s/om-sharp

GPL-3.0

9/19/2024, 11:25:22 AM (Europe/Amsterdam)

794d857db3bd59d747d041614a5bdd5654526749f2c74066bf5a7705c6403089

sharp-backslash.lisp

cac-t-u-s_om-sharp/src/api/foreign-interface/ffi/babel/src/sharp-backslash.lisp

;;;; -*- Mode: lisp; indent-tabs-mode: nil -*- ;;; ;;; sharp-backslash.lisp --- Alternative #\ dispatch code. ;;; ;;; Copyright (C) 2007-2009, Luis Oliveira <[email protected]> ;;; ;;; Permission is hereby granted, free of charge, to any person ;;; obtaining a copy of this software and associated documentation ;;; files (the "Software"), to deal in the Software without ;;; restriction, including without limitation the rights to use, copy, ;;; modify, merge, publish, distribute, sublicense, and/or sell copies ;;; of the Software, and to permit persons to whom the Software is ;;; furnished to do so, subject to the following conditions: ;;; ;;; The above copyright notice and this permission notice shall be ;;; included in all copies or substantial portions of the Software. ;;; ;;; THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, ;;; EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF ;;; MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND ;;; NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT ;;; HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, ;;; WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, ;;; OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER ;;; DEALINGS IN THE SOFTWARE. (in-package #:babel) #-allegro (defun sharp-backslash-reader (original-reader stream char numarg) (let ((1st-char (read-char stream))) (if (and (char-equal 1st-char #\u) ;; because #\z is not a digit char... (digit-char-p (peek-char nil stream nil #\z) 16)) ;; something better than READ would be nice here (let ((token (let ((*read-base* 16)) (read stream)))) (if (typep token 'babel-encodings::code-point) (code-char token) (if *read-suppress* nil (simple-reader-error stream "Unrecognized character name: u~A" token)))) (funcall original-reader (make-concatenated-stream (make-string-input-stream (string 1st-char)) stream) char numarg)))) ;;; Allegro's PEEK-CHAR seems broken in some situations, and the code ;;; above would generate an error about too many calls to UNREAD-CHAR. ;;; Then Allegro's original SHARP-BACKSLASH wants to UNREAD-CHAR ;;; twice, very weird. This is the best workaround I could think of. ;;; It sucks. #+allegro (defun sharp-backslash-reader (original-reader stream char numarg) (let* ((1st-char (read-char stream)) (rest (ignore-errors (excl::read-extended-token stream))) (code (when (and rest (char-equal 1st-char #\u)) (ignore-errors (parse-integer rest :radix 16))))) (if code (code-char code) (with-input-from-string (s (concatenate 'string "#\\" (string 1st-char) rest)) (read-char s) (read-char s) (funcall original-reader s char numarg))))) (defun make-sharp-backslash-reader () (let ((original-sharp-backslash (get-dispatch-macro-character #\# #\\))) (lambda (stream char numarg) (sharp-backslash-reader original-sharp-backslash stream char numarg)))) (defmacro enable-sharp-backslash-syntax () `(eval-when (:compile-toplevel :execute) (setf *readtable* (copy-readtable *readtable*)) (set-sharp-backslash-syntax-in-readtable) (values))) (defun set-sharp-backslash-syntax-in-readtable () (set-dispatch-macro-character #\# #\\ (make-sharp-backslash-reader)) (values))

Common Lisp

.lisp

cac-t-u-s/om-sharp

GPL-3.0

9/19/2024, 11:25:22 AM (Europe/Amsterdam)

f40ac60eb677604c3b39a30ae53b9b2b9be2f7d3267921b5df2e66377cd65c09

external-format.lisp

cac-t-u-s_om-sharp/src/api/foreign-interface/ffi/babel/src/external-format.lisp

;;;; -*- Mode: lisp; indent-tabs-mode: nil -*- ;;; ;;; external-format.lisp --- External format classes and functions. ;;; ;;; Copyright (C) 2007, Luis Oliveira <[email protected]> ;;; ;;; Permission is hereby granted, free of charge, to any person ;;; obtaining a copy of this software and associated documentation ;;; files (the "Software"), to deal in the Software without ;;; restriction, including without limitation the rights to use, copy, ;;; modify, merge, publish, distribute, sublicense, and/or sell copies ;;; of the Software, and to permit persons to whom the Software is ;;; furnished to do so, subject to the following conditions: ;;; ;;; The above copyright notice and this permission notice shall be ;;; included in all copies or substantial portions of the Software. ;;; ;;; THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, ;;; EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF ;;; MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND ;;; NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT ;;; HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, ;;; WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, ;;; OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER ;;; DEALINGS IN THE SOFTWARE. (in-package #:babel) (defvar *default-eol-style* #+windows :crlf #-windows :lf "The end-of-line style used by external formats if none is explicitly given. Depends on the OS the code is compiled on.") (deftype eol-style () "Possible end-of-line styles." '(member :cr :lf :crlf)) (defclass external-format () ((encoding :initarg :encoding :reader external-format-encoding :type character-encoding) (eol-style :initarg :eol-style :reader external-format-eol-style :type eol-style :initform *default-eol-style*)) (:documentation "An EXTERNAL-FORMAT consists in a combination of a Babel CHARACTER-ENCODING and an end-of-line style.")) (defmethod print-object ((ef external-format) stream) (print-unreadable-object (ef stream :type t :identity t) (format stream "~A ~A" (enc-name (external-format-encoding ef)) (external-format-eol-style ef)))) ;;; This interface is still somewhat sketchy. The rest of Babel ;;; doesn't really understand external formats, for instance. (defun make-external-format (encoding &key (eol-style *default-eol-style*)) (check-type eol-style eol-style) (make-instance 'external-format :encoding (get-character-encoding encoding) :eol-style eol-style)) (defun ensure-external-format (thing) (etypecase thing (external-format thing) (character-encoding (make-instance 'external-format :encoding thing)) (symbol (make-external-format thing)) (list (apply #'make-external-format thing)))) (defun external-format-equal (ef1 ef2) (and (eq (external-format-encoding ef1) (external-format-encoding ef2)) (eq (external-format-eol-style ef1) (external-format-eol-style ef2)))) (declaim (inline lookup-mapping)) (defun lookup-mapping (ht encoding) "HT should be an hashtable created by INSTANTIATE-CONCRETE-MAPPINGS. ENCODING should be either an external format, an encoding object or a keyword symbol denoting a character encoding name or one of its aliases." (or (etypecase encoding (keyword (gethash encoding ht)) (babel-encodings::concrete-mapping encoding) (character-encoding (gethash (enc-name encoding) ht)) (external-format (gethash (enc-name (external-format-encoding encoding)) ht))) (error "~S is not a valid encoding designator" encoding)))

Common Lisp

.lisp

cac-t-u-s/om-sharp

GPL-3.0

9/19/2024, 11:25:22 AM (Europe/Amsterdam)

8d1cc8986297d72fcde4457e865437377e2693282e71bb57f70e5146c0154368

enc-iso-8859.lisp

cac-t-u-s_om-sharp/src/api/foreign-interface/ffi/babel/src/enc-iso-8859.lisp

;;;; -*- Mode: lisp; indent-tabs-mode: nil -*- ;;; ;;; enc-iso-8859.lisp --- ISO-8859-* encodings. ;;; ;;; Copyright (C) 2007, Luis Oliveira <[email protected]> ;;; ;;; Permission is hereby granted, free of charge, to any person ;;; obtaining a copy of this software and associated documentation ;;; files (the "Software"), to deal in the Software without ;;; restriction, including without limitation the rights to use, copy, ;;; modify, merge, publish, distribute, sublicense, and/or sell copies ;;; of the Software, and to permit persons to whom the Software is ;;; furnished to do so, subject to the following conditions: ;;; ;;; The above copyright notice and this permission notice shall be ;;; included in all copies or substantial portions of the Software. ;;; ;;; THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, ;;; EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF ;;; MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND ;;; NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT ;;; HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, ;;; WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, ;;; OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER ;;; DEALINGS IN THE SOFTWARE. ;;; This implementation is largely based on OpenMCL's l1-unicode.lisp ;;; Copyright (C) 2006 Clozure Associates and contributors. (in-package #:babel-encodings) ;;; Typically, ISO-8859-* codes in the range #x00-#x9f map straight ;;; through, while codes #xa0-#xff select arbitrary Unicode characters ;;; that are commonly used in some locale. (Sometimes the break is at ;;; #x80 instead of #xa0). ;;; ;;; (comment from OpenMCL's ccl/level-1/l1-unicode.lisp) (define-character-encoding :iso-8859-1 "An 8-bit, fixed-width character encoding in which all character codes map to their Unicode equivalents. Intended to support most characters used in most Western European languages." :aliases '(:latin-1 :latin1) :literal-char-code-limit 256) (define-unibyte-encoder :iso-8859-1 (code) (if (>= code 256) (handle-error) code)) (define-unibyte-decoder :iso-8859-1 (octet) octet) (define-character-encoding :iso-8859-2 "An 8-bit, fixed-width character encoding in which codes #x00-#x9f map to their Unicode equivalents and other codes map to other Unicode character values. Intended to provide most characters found in most languages used in Central/Eastern Europe." :aliases '(:latin-2 :latin2) :literal-char-code-limit #xa0) (define-constant +unicode-00a0-0180-to-iso-8859-2+ #(#xa0 nil nil nil #xa4 nil nil #xa7 ; #xa0-#xa7 #xa8 nil nil nil nil #xad nil nil ; #xa8-#xaf #xb0 nil nil nil #xb4 nil nil nil ; #xb0-#xb7 #xb8 nil nil nil nil nil nil nil ; #xb8-#xbf nil #xc1 #xc2 nil #xc4 nil nil #xc7 ; #xc0-#xc7 nil #xc9 nil #xcb nil #xcd #xce nil ; #xc8-#xcf nil nil nil #xd3 #xd4 nil #xd6 #xd7 ; #xd0-#xd7 nil nil #xda nil #xdc #xdd nil #xdf ; #xd8-#xdf nil #xe1 #xe2 nil #xe4 nil nil #xe7 ; #xe0-#xe7 nil #xe9 nil #xeb nil #xed #xee nil ; #xe8-#xef nil nil nil #xf3 #xf4 nil #xf6 #xf7 ; #xf0-#xf7 nil nil #xfa nil #xfc #xfd nil nil ; #xf8-#xff ;; #x0100 nil nil #xc3 #xe3 #xa1 #xb1 #xc6 #xe6 ; #x100-#x107 nil nil nil nil #xc8 #xe8 #xcf #xef ; #x108-#x10f #xd0 #xf0 nil nil nil nil nil nil ; #x110-#x117 #xca #xea #xcc #xec nil nil nil nil ; #x118-#x11f nil nil nil nil nil nil nil nil ; #x120-#x127 nil nil nil nil nil nil nil nil ; #x128-#x12f nil nil nil nil nil nil nil nil ; #x130-#x137 nil #xc5 #xe5 nil nil #xa5 #xb5 nil ; #x138-#x13f nil #xa3 #xb3 #xd1 #xf1 nil nil #xd2 ; #x140-#x147 #xf2 nil nil nil nil nil nil nil ; #x148-#x14f #xd5 #xf5 nil nil #xc0 #xe0 nil nil ; #x150-#x157 #xd8 #xf8 #xa6 #xb6 nil nil #xaa #xba ; #x158-#x15f #xa9 #xb9 #xde #xfe #xab #xbb nil nil ; #x160-#x167 nil nil nil nil nil nil #xd9 #xf9 ; #x168-#x16f #xdb #xfb nil nil nil nil nil nil ; #x170-#x177 nil #xac #xbc #xaf #xbf #xae #xbe nil) ; #x178-#x17f :test #'equalp) (define-constant +unicode-02c0-02e0-to-iso-8859-2+ #(nil nil nil nil nil nil nil #xb7 ; #x2c0-#x2c7 nil nil nil nil nil nil nil nil ; #x2c8-#x2cf nil nil nil nil nil nil nil nil ; #x2d0-#x2d7 #xa2 #xff nil #xb2 nil #xbd nil nil) ; #x2d8-#x2df :test #'equalp) (define-unibyte-encoder :iso-8859-2 (code) (or (cond ((< code #xa0) code) ((< code #x180) (svref +unicode-00a0-0180-to-iso-8859-2+ (the ub8 (- code #xa0)))) ((<= #x2c0 code #x2df) (svref +unicode-02c0-02e0-to-iso-8859-2+ (the ub8 (- code #x2c0))))) (handle-error))) (define-constant +iso-8859-2-to-unicode+ #(;; #xa0 #x00a0 #x0104 #x02d8 #x0141 #x00a4 #x013d #x015a #x00a7 #x00a8 #x0160 #x015e #x0164 #x0179 #x00ad #x017d #x017b ;; #xb0 #x00b0 #x0105 #x02db #x0142 #x00b4 #x013e #x015b #x02c7 #x00b8 #x0161 #x015f #x0165 #x017a #x02dd #x017e #x017c ;; #xc0 #x0154 #x00c1 #x00c2 #x0102 #x00c4 #x0139 #x0106 #x00c7 #x010c #x00c9 #x0118 #x00cb #x011a #x00cd #x00ce #x010e ;; #xd0 #x0110 #x0143 #x0147 #x00d3 #x00d4 #x0150 #x00d6 #x00d7 #x0158 #x016e #x00da #x0170 #x00dc #x00dd #x0162 #x00df ;; #xe0 #x0155 #x00e1 #x00e2 #x0103 #x00e4 #x013a #x0107 #x00e7 #x010d #x00e9 #x0119 #x00eb #x011b #x00ed #x00ee #x010f ;; #xf0 #x0111 #x0144 #x0148 #x00f3 #x00f4 #x0151 #x00f6 #x00f7 #x0159 #x016f #x00fa #x0171 #x00fc #x00fd #x0163 #x02d9) :test #'equalp) (define-unibyte-decoder :iso-8859-2 (octet) (if (< octet #xa0) octet (svref +iso-8859-2-to-unicode+ (the ub8 (- octet #xa0))))) (define-character-encoding :iso-8859-3 "An 8-bit, fixed-width character encoding in which codes #x00-#x9f map to their Unicode equivalents and other codes map to other Unicode character values. Intended to provide most characters found in most languages used in Southern Europe." :aliases '(:latin-3 :latin3) :literal-char-code-limit #xa0) (define-constant +unicode-a0-100-to-iso-8859-3+ #(#xa0 nil nil #xa3 #xa4 nil nil #xa7 ; #xa0-#xa7 #xa8 nil nil nil nil #xad nil nil ; #xa8-#xaf #xb0 nil #xb2 #xb3 #xb4 #xb5 nil #xb7 ; #xb0-#xb7 #xb8 nil nil nil nil #xbd nil nil ; #xb8-#xbf #xc0 #xc1 #xc2 nil #xc4 nil nil #xc7 ; #xc0-#xc7 #xc8 #xc9 #xca #xcb #xcc #xcd #xce #xcf ; #xc8-#xcf nil #xd1 #xd2 #xd3 #xd4 nil #xd6 #xd7 ; #xd0-#xd7 nil #xd9 #xda #xdb #xdc nil nil #xdf ; #xd8-#xdf #xe0 #xe1 #xe2 nil #xe4 nil nil #xe7 ; #xe0-#xe7 #xe8 #xe9 #xea #xeb #xec #xed #xee #xef ; #xe8-#xef nil #xf1 #xf2 #xf3 #xf4 nil #xf6 #xf7 ; #xf0-#xf7 nil #xf9 #xfa #xfb #xfc nil nil nil) ; #xf8-#xff :test #'equalp) (define-constant +unicode-108-180-to-iso-8859-3+ #(#xc6 #xe6 #xc5 #xe5 #x00 #x00 #x00 #x00 ; #x108-#x10f nil nil nil nil nil nil nil nil ; #x110-#x117 nil nil nil nil #xd8 #xf8 #xab #xbb ; #x118-#x11f #xd5 #xf5 nil nil #xa6 #xb6 #xa1 #xb1 ; #x120-#x127 nil nil nil nil nil nil nil nil ; #x128-#x12f #xa9 #xb9 nil nil #xac #xbc nil nil ; #x130-#x137 nil nil nil nil nil nil nil nil ; #x138-#x13f nil nil nil nil nil nil nil nil ; #x140-#x147 nil nil nil nil nil nil nil nil ; #x148-#x14f nil nil nil nil nil nil nil nil ; #x150-#x157 nil nil nil nil #xde #xfe #xaa #xba ; #x158-#x15f nil nil nil nil nil nil nil nil ; #x160-#x167 nil nil nil nil #xdd #xfd nil nil ; #x168-#x16f nil nil nil nil nil nil nil nil ; #x170-#x177 nil nil nil #xaf #xbf nil nil nil) ; #x178-#x17f :test #'equalp) (define-constant +unicode-2d8-2e0-to-iso-8859-3+ #(#xa2 #xff nil nil nil nil nil nil) ; #x2d8-#x2df :test #'equalp) (define-unibyte-encoder :iso-8859-3 (code) (or (cond ((< code #xa0) code) ((< code #x100) (svref +unicode-a0-100-to-iso-8859-3+ (the ub8 (- code #xa0)))) ((<= #x108 code #x17f) (svref +unicode-108-180-to-iso-8859-3+ (the ub8 (- code #x108)))) ((<= #x2d8 code #x2df) (svref +unicode-2d8-2e0-to-iso-8859-3+ (the ub8 (- code #x2d8))))) (handle-error))) (define-constant +iso-8859-3-to-unicode+ #(;; #xa0 #x00a0 #x0126 #x02d8 #x00a3 #x00a4 #xfffd #x0124 #x00a7 #x00a8 #x0130 #x015e #x011e #x0134 #x00ad #xfffd #x017b ;; #xb0 #x00b0 #x0127 #x00b2 #x00b3 #x00b4 #x00b5 #x0125 #x00b7 #x00b8 #x0131 #x015f #x011f #x0135 #x00bd #xfffd #x017c ;; #xc0 #x00c0 #x00c1 #x00c2 #xfffd #x00c4 #x010a #x0108 #x00c7 #x00c8 #x00c9 #x00ca #x00cb #x00cc #x00cd #x00ce #x00cf ;; #xd0 #xfffd #x00d1 #x00d2 #x00d3 #x00d4 #x0120 #x00d6 #x00d7 #x011c #x00d9 #x00da #x00db #x00dc #x016c #x015c #x00df ;; #xe0 #x00e0 #x00e1 #x00e2 #xfffd #x00e4 #x010b #x0109 #x00e7 #x00e8 #x00e9 #x00ea #x00eb #x00ec #x00ed #x00ee #x00ef ;; #xf0 #xfffd #x00f1 #x00f2 #x00f3 #x00f4 #x0121 #x00f6 #x00f7 #x011d #x00f9 #x00fa #x00fb #x00fc #x016d #x015d #x02d9) :test #'equalp) (define-unibyte-decoder :iso-8859-3 (octet) (if (< octet #xa0) octet (svref +iso-8859-3-to-unicode+ (the ub8 (- octet #xa0))))) (define-character-encoding :iso-8859-4 "An 8-bit, fixed-width character encoding in which codes #x00-#x9f map to their Unicode equivalents and other codes map to other Unicode character values. Intended to provide most characters found in most languages used in Northern Europe." :aliases '(:latin-4 :latin4) :literal-char-code-limit #xa0) (define-constant +unicode-a0-180-to-iso-8859-4+ #(#xa0 nil nil nil #xa4 nil nil #xa7 ; #xa0-#xa7 #xa8 nil nil nil nil #xad nil #xaf ; #xa8-#xaf #xb0 nil nil nil #xb4 nil nil nil ; #xb0-#xb7 #xb8 nil nil nil nil nil nil nil ; #xb8-#xbf nil #xc1 #xc2 #xc3 #xc4 #xc5 #xc6 nil ; #xc0-#xc7 nil #xc9 nil #xcb nil #xcd #xce nil ; #xc8-#xcf nil nil nil nil #xd4 #xd5 #xd6 #xd7 ; #xd0-#xd7 #xd8 nil #xda #xdb #xdc nil nil #xdf ; #xd8-#xdf nil #xe1 #xe2 #xe3 #xe4 #xe5 #xe6 nil ; #xe0-#xe7 nil #xe9 nil #xeb nil #xed #xee nil ; #xe8-#xef nil nil nil nil #xf4 #xf5 #xf6 #xf7 ; #xf0-#xf7 #xf8 nil #xfa #xfb #xfc nil nil nil ; #xf8-#xff #xc0 #xe0 nil nil #xa1 #xb1 nil nil ; #x100-#x107 nil nil nil nil #xc8 #xe8 nil nil ; #x108-#x10f #xd0 #xf0 #xaa #xba nil nil #xcc #xec ; #x110-#x117 #xca #xea nil nil nil nil nil nil ; #x118-#x11f nil nil #xab #xbb nil nil nil nil ; #x120-#x127 #xa5 #xb5 #xcf #xef nil nil #xc7 #xe7 ; #x128-#x12f nil nil nil nil nil nil #xd3 #xf3 ; #x130-#x137 #xa2 nil nil #xa6 #xb6 nil nil nil ; #x138-#x13f nil nil nil nil nil #xd1 #xf1 nil ; #x140-#x147 nil nil #xbd #xbf #xd2 #xf2 nil nil ; #x148-#x14f nil nil nil nil nil nil #xa3 #xb3 ; #x150-#x157 nil nil nil nil nil nil nil nil ; #x158-#x15f #xa9 #xb9 nil nil nil nil #xac #xbc ; #x160-#x167 #xdd #xfd #xde #xfe nil nil nil nil ; #x168-#x16f nil nil #xd9 #xf9 nil nil nil nil ; #x170-#x177 nil nil nil nil nil #xae #xbe nil) ; #x178-#x17f :test #'equalp) (define-constant +unicode-2c0-2e0-to-iso-8859-4+ #(nil nil nil nil nil nil nil #xb7 ; #x2c0-#x2c7 nil nil nil nil nil nil nil nil ; #x2c8-#x2cf nil nil nil nil nil nil nil nil ; #x2d0-#x2d7 nil #xff nil #xb2 nil nil nil nil) ; #x2d8-#x2df :test #'equalp) (define-unibyte-encoder :iso-8859-4 (code) (or (cond ((< code #xa0) code) ((< code #x180) (svref +unicode-a0-180-to-iso-8859-4+ (the ub8 (- code #xa0)))) ((<= #x2c0 code #x2df) (svref +unicode-2c0-2e0-to-iso-8859-4+ (the ub8 (- code #x2c0))))) (handle-error))) (define-constant +iso-8859-4-to-unicode+ #(;; #xa0 #x00a0 #x0104 #x0138 #x0156 #x00a4 #x0128 #x013b #x00a7 #x00a8 #x0160 #x0112 #x0122 #x0166 #x00ad #x017d #x00af ;; #xb0 #x00b0 #x0105 #x02db #x0157 #x00b4 #x0129 #x013c #x02c7 #x00b8 #x0161 #x0113 #x0123 #x0167 #x014a #x017e #x014b ;; #xc0 #x0100 #x00c1 #x00c2 #x00c3 #x00c4 #x00c5 #x00c6 #x012e #x010c #x00c9 #x0118 #x00cb #x0116 #x00cd #x00ce #x012a ;; #xd0 #x0110 #x0145 #x014c #x0136 #x00d4 #x00d5 #x00d6 #x00d7 #x00d8 #x0172 #x00da #x00db #x00dc #x0168 #x016a #x00df ;; #xe0 #x0101 #x00e1 #x00e2 #x00e3 #x00e4 #x00e5 #x00e6 #x012f #x010d #x00e9 #x0119 #x00eb #x0117 #x00ed #x00ee #x012b ;; #xf0 #x0111 #x0146 #x014d #x0137 #x00f4 #x00f5 #x00f6 #x00f7 #x00f8 #x0173 #x00fa #x00fb #x00fc #x0169 #x016b #x02d9) :test #'equalp) (define-unibyte-decoder :iso-8859-4 (octet) (if (< octet #xa0) octet (svref +iso-8859-4-to-unicode+ (the ub8 (- octet #xa0))))) (define-character-encoding :iso-8859-5 "An 8-bit, fixed-width character encoding in which codes #x00-#x9f map to their Unicode equivalents and other codes map to other Unicode character values. Intended to provide most characters found in the Cyrillic alphabet." :aliases '(:cyrillic) :literal-char-code-limit #xa0) (define-constant +unicode-a0-b0-to-iso-8859-5+ #(#xa0 nil nil nil nil nil nil #xfd ; #xa0-#xa7 nil nil nil nil nil #xad nil nil) ; #xa8-#xaf :test #'equalp) (define-constant +unicode-400-460-to-iso-8859-5+ #(nil #xa1 #xa2 #xa3 #xa4 #xa5 #xa6 #xa7 ; #x400-#x407 #xa8 #xa9 #xaa #xab #xac nil #xae #xaf ; #x408-#x40f #xb0 #xb1 #xb2 #xb3 #xb4 #xb5 #xb6 #xb7 ; #x410-#x417 #xb8 #xb9 #xba #xbb #xbc #xbd #xbe #xbf ; #x418-#x41f #xc0 #xc1 #xc2 #xc3 #xc4 #xc5 #xc6 #xc7 ; #x420-#x427 #xc8 #xc9 #xca #xcb #xcc #xcd #xce #xcf ; #x428-#x42f #xd0 #xd1 #xd2 #xd3 #xd4 #xd5 #xd6 #xd7 ; #x430-#x437 #xd8 #xd9 #xda #xdb #xdc #xdd #xde #xdf ; #x438-#x43f #xe0 #xe1 #xe2 #xe3 #xe4 #xe5 #xe6 #xe7 ; #x440-#x447 #xe8 #xe9 #xea #xeb #xec #xed #xee #xef ; #x448-#x44f nil #xf1 #xf2 #xf3 #xf4 #xf5 #xf6 #xf7 ; #x450-#x457 #xf8 #xf9 #xfa #xfb #xfc nil #xfe #xff) ; #x458-#x45f :test #'equalp) (define-unibyte-encoder :iso-8859-5 (code) (or (cond ((< code #xa0) code) ((< code #xb0) (svref +unicode-a0-b0-to-iso-8859-5+ (the ub8 (- code #xa0)))) ((<= #x400 code #x45f) (svref +unicode-400-460-to-iso-8859-5+ (the ub8 (- code #x400)))) ;; the Numero sign ((= code #x2116) #xf0)) (handle-error))) (define-constant +iso-8859-5-to-unicode+ #(;; #xa0 #x00a0 #x0401 #x0402 #x0403 #x0404 #x0405 #x0406 #x0407 #x0408 #x0409 #x040a #x040b #x040c #x00ad #x040e #x040f ;; #xb0 #x0410 #x0411 #x0412 #x0413 #x0414 #x0415 #x0416 #x0417 #x0418 #x0419 #x041a #x041b #x041c #x041d #x041e #x041f ;; #xc0 #x0420 #x0421 #x0422 #x0423 #x0424 #x0425 #x0426 #x0427 #x0428 #x0429 #x042a #x042b #x042c #x042d #x042e #x042f ;; #xd0 #x0430 #x0431 #x0432 #x0433 #x0434 #x0435 #x0436 #x0437 #x0438 #x0439 #x043a #x043b #x043c #x043d #x043e #x043f ;; #xe0 #x0440 #x0441 #x0442 #x0443 #x0444 #x0445 #x0446 #x0447 #x0448 #x0449 #x044a #x044b #x044c #x044d #x044e #x044f ;; #xf0 #x2116 #x0451 #x0452 #x0453 #x0454 #x0455 #x0456 #x0457 #x0458 #x0459 #x045a #x045b #x045c #x00a7 #x045e #x045f) :test #'equalp) (define-unibyte-decoder :iso-8859-5 (octet) (if (< octet #xa0) octet (svref +iso-8859-5-to-unicode+ (the ub8 (- octet #xa0))))) (define-character-encoding :iso-8859-6 "An 8-bit, fixed-width character encoding in which codes #x00-#x9f map to their Unicode equivalents and other codes map to other Unicode character values. Intended to provide most characters found in the Arabic alphabet." :aliases '(:arabic) :literal-char-code-limit #xa0) (define-constant +unicode-a0-b0-to-iso-8859-6+ #(#xa0 nil nil nil #xa4 nil nil nil ; #xa0-#xa7 nil nil nil nil nil #xad nil nil) ; #xa8-#xaf :test #'equalp) (define-constant +unicode-608-658-to-iso-8859-6+ #(nil nil nil nil #xac nil nil nil ; #x608-#x60f nil nil nil nil nil nil nil nil ; #x610-#x617 nil nil nil #xbb nil nil nil #xbf ; #x618-#x61f nil #xc1 #xc2 #xc3 #xc4 #xc5 #xc6 #xc7 ; #x620-#x627 #xc8 #xc9 #xca #xcb #xcc #xcd #xce #xcf ; #x628-#x62f #xd0 #xd1 #xd2 #xd3 #xd4 #xd5 #xd6 #xd7 ; #x630-#x637 #xd8 #xd9 #xda nil nil nil nil nil ; #x638-#x63f #xe0 #xe1 #xe2 #xe3 #xe4 #xe5 #xe6 #xe7 ; #x640-#x647 #xe8 #xe9 #xea #xeb #xec #xed #xee #xef ; #x648-#x64f #xf0 #xf1 #xf2 nil nil nil nil nil) ; #x650-#x657 :test #'equalp) (define-unibyte-encoder :iso-8859-6 (code) (or (cond ((< code #xa0) code) ((< code #xb0) (svref +unicode-a0-b0-to-iso-8859-6+ (the ub8 (- code #xa0)))) ((<= #x608 code #x657) (svref +unicode-608-658-to-iso-8859-6+ (the ub8 (- code #x608))))) (handle-error))) (define-constant +iso-8859-6-to-unicode+ #(;; #xa0 #x00a0 #xfffd #xfffd #xfffd #x00a4 #xfffd #xfffd #xfffd #xfffd #xfffd #xfffd #xfffd #x060c #x00ad #xfffd #xfffd ;; #xb0 #xfffd #xfffd #xfffd #xfffd #xfffd #xfffd #xfffd #xfffd #xfffd #xfffd #xfffd #x061b #xfffd #xfffd #xfffd #x061f ;; #xc0 #xfffd #x0621 #x0622 #x0623 #x0624 #x0625 #x0626 #x0627 #x0628 #x0629 #x062a #x062b #x062c #x062d #x062e #x062f ;; #xd0 #x0630 #x0631 #x0632 #x0633 #x0634 #x0635 #x0636 #x0637 #x0638 #x0639 #x063a #xfffd #xfffd #xfffd #xfffd #xfffd ;; #xe0 #x0640 #x0641 #x0642 #x0643 #x0644 #x0645 #x0646 #x0647 #x0648 #x0649 #x064a #x064b #x064c #x064d #x064e #x064f ;; #xf0 #x0650 #x0651 #x0652 #xfffd #xfffd #xfffd #xfffd #xfffd #xfffd #xfffd #xfffd #xfffd #xfffd #xfffd #xfffd #xfffd) :test #'equalp) (define-unibyte-decoder :iso-8859-6 (octet) (if (< octet #xa0) octet (svref +iso-8859-6-to-unicode+ (the ub8 (- octet #xa0))))) (define-character-encoding :iso-8859-7 "An 8-bit, fixed-width character encoding in which codes #x00-#x9f map to their Unicode equivalents and other codes map to other Unicode character values. Intended to provide most characters found in the Greek alphabet." :aliases '(:greek) :literal-char-code-limit #xa0) (define-constant +unicode-a0-c0-to-iso-8859-7+ #(#xa0 nil nil #xa3 nil nil #xa6 #xa7 ; #xa0-#xa7 #xa8 #xa9 nil #xab #xac #xad nil nil ; #xa8-#xaf #xb0 #xb1 #xb2 #xb3 nil nil nil #xb7 ; #xb0-#xb7 nil nil nil #xbb nil #xbd nil nil) ; #xb8-#xbf :test #'equalp) (define-constant +unicode-378-3d0-to-iso-8859-7+ #(nil nil #xaa nil nil nil nil nil ; #x378-#x37f nil nil nil nil #xb4 #xb5 #xb6 nil ; #x380-#x387 #xb8 #xb9 #xba nil #xbc nil #xbe #xbf ; #x388-#x38f #xc0 #xc1 #xc2 #xc3 #xc4 #xc5 #xc6 #xc7 ; #x390-#x397 #xc8 #xc9 #xca #xcb #xcc #xcd #xce #xcf ; #x398-#x39f #xd0 #xd1 nil #xd3 #xd4 #xd5 #xd6 #xd7 ; #x3a0-#x3a7 #xd8 #xd9 #xda #xdb #xdc #xdd #xde #xdf ; #x3a8-#x3af #xe0 #xe1 #xe2 #xe3 #xe4 #xe5 #xe6 #xe7 ; #x3b0-#x3b7 #xe8 #xe9 #xea #xeb #xec #xed #xee #xef ; #x3b8-#x3bf #xf0 #xf1 #xf2 #xf3 #xf4 #xf5 #xf6 #xf7 ; #x3c0-#x3c7 #xf8 #xf9 #xfa #xfb #xfc #xfd #xfe nil) ; #x3c8-#x3cf :test #'equalp) (define-constant +unicode-2010-2020-to-iso-8859-7+ #(nil nil nil nil nil #xaf nil nil ; #x2010-#x2017 #xa1 #xa2 nil nil nil nil nil nil) ; #x2018-#x201f :test #'equalp) (define-constant +unicode-20ac-20b0-to-iso-8859-7+ #(#xa4 nil nil #xa5) :test #'equalp) (define-unibyte-encoder :iso-8859-7 (code) (or (cond ((< code #xa0) code) ((< code #xc0) (svref +unicode-a0-c0-to-iso-8859-7+ (the ub8 (- code #xa0)))) ((<= #x378 code #x3cf) (svref +unicode-378-3d0-to-iso-8859-7+ (the ub8 (- code #x378)))) ((<= #x2010 code #x201f) (svref +unicode-2010-2020-to-iso-8859-7+ (the ub8 (- code #x2010)))) ((<= #x201c code #x20af) (svref +unicode-20ac-20b0-to-iso-8859-7+ (the ub8 (- code #x20ac))))) (handle-error))) (define-constant +iso-8859-7-to-unicode+ #(;; #xa0 #x00a0 #x2018 #x2019 #x00a3 #x20ac #x20af #x00a6 #x00a7 #x00a8 #x00a9 #x037a #x00ab #x00ac #x00ad #xfffd #x2015 ;; #xb0 #x00b0 #x00b1 #x00b2 #x00b3 #x0384 #x0385 #x0386 #x00b7 #x0388 #x0389 #x038a #x00bb #x038c #x00bd #x038e #x038f ;; #xc0 #x0390 #x0391 #x0392 #x0393 #x0394 #x0395 #x0396 #x0397 #x0398 #x0399 #x039a #x039b #x039c #x039d #x039e #x039f ;; #xd0 #x03a0 #x03a1 #xfffd #x03a3 #x03a4 #x03a5 #x03a6 #x03a7 #x03a8 #x03a9 #x03aa #x03ab #x03ac #x03ad #x03ae #x03af ;; #xe0 #x03b0 #x03b1 #x03b2 #x03b3 #x03b4 #x03b5 #x03b6 #x03b7 #x03b8 #x03b9 #x03ba #x03bb #x03bc #x03bd #x03be #x03bf ;; #xf0 #x03c0 #x03c1 #x03c2 #x03c3 #x03c4 #x03c5 #x03c6 #x03c7 #x03c8 #x03c9 #x03ca #x03cb #x03cc #x03cd #x03ce #xfffd) :test #'equalp) (define-unibyte-decoder :iso-8859-7 (octet) (if (< octet #xa0) octet (svref +iso-8859-7-to-unicode+ (the ub8 (- octet #xa0))))) (define-character-encoding :iso-8859-8 "An 8-bit, fixed-width character encoding in which codes #x00-#x9f map to their Unicode equivalents and other codes map to other Unicode character values. Intended to provide most characters found in the Hebrew alphabet." :aliases '(:hebrew) :literal-char-code-limit #xa0) (define-constant +unicode-a0-f8-to-iso-8859-8+ #(#xa0 nil #xa2 #xa3 #xa4 #xa5 #xa6 #xa7 ; #xa0-#xa7 #xa8 #xa9 nil #xab #xac #xad #xae #xaf ; #xa8-#xaf #xb0 #xb1 #xb2 #xb3 #xb4 #xb5 #xb6 #xb7 ; #xb0-#xb7 #xb8 #xb9 nil #xbb #xbc #xbd #xbe nil ; #xb8-#xbf nil nil nil nil nil nil nil nil ; #xc0-#xc7 nil nil nil nil nil nil nil nil ; #xc8-#xcf nil nil nil nil nil nil nil #xaa ; #xd0-#xd7 nil nil nil nil nil nil nil nil ; #xd8-#xdf nil nil nil nil nil nil nil nil ; #xe0-#xe7 nil nil nil nil nil nil nil nil ; #xe8-#xef nil nil nil nil nil nil nil #xba) ; #xf0-#xf7 :test #'equalp) (define-constant +unicode-5d0-5f0-to-iso-8859-8+ #(#xe0 #xe1 #xe2 #xe3 #xe4 #xe5 #xe6 #xe7 ; #x5d0-#x5d7 #xe8 #xe9 #xea #xeb #xec #xed #xee #xef ; #x5d8-#x5df #xf0 #xf1 #xf2 #xf3 #xf4 #xf5 #xf6 #xf7 ; #x5e0-#x5e7 #xf8 #xf9 #xfa nil nil nil nil nil) ; #x5e8-#x5ef :test #'equalp) (define-constant +unicode-2008-2018-to-iso-8859-8+ #(nil nil nil nil nil nil #xfd #xfe ; #x2008-#x200f nil nil nil nil nil nil nil #xdf) ; #x2010-#x2017 :test #'equalp) (define-unibyte-encoder :iso-8859-8 (code) (or (cond ((< code #xa0) code) ((< code #xf8) (svref +unicode-a0-f8-to-iso-8859-8+ (the ub8 (- code #xa0)))) ((<= #x5d0 code #x5ef) (svref +unicode-5d0-5f0-to-iso-8859-8+ (the ub8 (- code #x5d0)))) ((<= #x2008 code #x201f) (svref +unicode-2008-2018-to-iso-8859-8+ (the ub8 (- code #x2008))))) (handle-error))) (define-constant +iso-8859-8-to-unicode+ #(;; #xa0 #x00a0 #xfffd #x00a2 #x00a3 #x00a4 #x00a5 #x00a6 #x00a7 #x00a8 #x00a9 #x00d7 #x00ab #x00ac #x00ad #x00ae #x00af ;; #xb0 #x00b0 #x00b1 #x00b2 #x00b3 #x00b4 #x00b5 #x00b6 #x00b7 #x00b8 #x00b9 #x00f7 #x00bb #x00bc #x00bd #x00be #xfffd ;; #xc0 #xfffd #xfffd #xfffd #xfffd #xfffd #xfffd #xfffd #xfffd #xfffd #xfffd #xfffd #xfffd #xfffd #xfffd #xfffd #xfffd ;; #xd0 #xfffd #xfffd #xfffd #xfffd #xfffd #xfffd #xfffd #xfffd #xfffd #xfffd #xfffd #xfffd #xfffd #xfffd #xfffd #x2017 ;; #xe0 #x05d0 #x05d1 #x05d2 #x05d3 #x05d4 #x05d5 #x05d6 #x05d7 #x05d8 #x05d9 #x05da #x05db #x05dc #x05dd #x05de #x05df ;; #xf0 #x05e0 #x05e1 #x05e2 #x05e3 #x05e4 #x05e5 #x05e6 #x05e7 #x05e8 #x05e9 #x05ea #xfffd #xfffd #x200e #x200f #xfffd) :test #'equalp) (define-unibyte-decoder :iso-8859-8 (octet) (if (< octet #xa0) octet (svref +iso-8859-8-to-unicode+ (the ub8 (- octet #xa0))))) (define-character-encoding :iso-8859-9 "An 8-bit, fixed-width character encoding in which codes #x00-#xcf map to their Unicode equivalents and other codes map to other Unicode character values. Intended to provide most characters found in the Turkish alphabet." :aliases '(:latin-5 :latin5) :decode-literal-code-unit-limit #xd0 :encode-literal-code-unit-limit #xa0) (define-constant +unicode-d0-100-to-iso-8859-9+ #(nil #xd1 #xd2 #xd3 #xd4 #xd5 #xd6 #xd7 ; #xd0-#xd7 #xd8 #xd9 #xda #xdb #xdc nil nil #xdf ; #xd8-#xdf #xe0 #xe1 #xe2 #xe3 #xe4 #xe5 #xe6 #xe7 ; #xe0-#xe7 #xe8 #xe9 #xea #xeb #xec #xed #xee #xef ; #xe8-#xef nil #xf1 #xf2 #xf3 #xf4 #xf5 #xf6 #xf7 ; #xf0-#xf7 #xf8 #xf9 #xfa #xfb #xfc nil nil #xff) ; #xf8-#xff :test #'equalp) (define-constant +unicode-118-160-to-iso-8859-9+ #(nil nil nil nil nil nil #xd0 #xf0 ; #x118-#x11f nil nil nil nil nil nil nil nil ; #x120-#x127 nil nil nil nil nil nil nil nil ; #x128-#x12f #xdd #xfd nil nil nil nil nil nil ; #x130-#x137 nil nil nil nil nil nil nil nil ; #x138-#x13f nil nil nil nil nil nil nil nil ; #x140-#x147 nil nil nil nil nil nil nil nil ; #x148-#x14f nil nil nil nil nil nil nil nil ; #x150-#x157 nil nil nil nil nil nil #xde #xfe) ; #x158-#x15f :test #'equalp) (define-unibyte-encoder :iso-8859-9 (code) (or (cond ((< code #xd0) code) ((< code #x100) (svref +unicode-d0-100-to-iso-8859-9+ (the ub8 (- code #xd0)))) ((<= #x118 code #x15f) (svref +unicode-118-160-to-iso-8859-9+ (the ub8 (- code #x118))))) (handle-error))) (define-constant +iso-8859-9-to-unicode+ #(;; #xd0 #x011e #x00d1 #x00d2 #x00d3 #x00d4 #x00d5 #x00d6 #x00d7 #x00d8 #x00d9 #x00da #x00db #x00dc #x0130 #x015e #x00df ;; #xe0 #x00e0 #x00e1 #x00e2 #x00e3 #x00e4 #x00e5 #x00e6 #x00e7 #x00e8 #x00e9 #x00ea #x00eb #x00ec #x00ed #x00ee #x00ef ;; #xf0 #x011f #x00f1 #x00f2 #x00f3 #x00f4 #x00f5 #x00f6 #x00f7 #x00f8 #x00f9 #x00fa #x00fb #x00fc #x0131 #x015f #x00ff) :test #'equalp) (define-unibyte-decoder :iso-8859-9 (octet) (if (< octet #xd0) octet (svref +iso-8859-9-to-unicode+ (the ub8 (- octet #xd0))))) (define-character-encoding :iso-8859-10 "An 8-bit, fixed-width character encoding in which codes #x00-#x9f map to their Unicode equivalents and other codes map to other Unicode character values. Intended to provide most characters found in Nordic alphabets." :aliases '(:latin-6 :latin6) :literal-char-code-limit #xa0) (define-constant +unicode-a0-180-to-iso-8859-10+ #(#xa0 nil nil nil nil nil nil #xa7 ; #xa0-#xa7 nil nil nil nil nil #xad nil nil ; #xa8-#xaf #xb0 nil nil nil nil nil nil #xb7 ; #xb0-#xb7 nil nil nil nil nil #x2015 nil nil ; #xb8-#xbf nil #xc1 #xc2 #xc3 #xc4 #xc5 #xc6 nil ; #xc0-#xc7 nil #xc9 nil #xcb nil #xcd #xce #xcf ; #xc8-#xcf #xd0 nil nil #xd3 #xd4 #xd5 #xd6 nil ; #xd0-#xd7 #xd8 nil #xda #xdb #xdc #xdd #xde #xdf ; #xd8-#xdf nil #xe1 #xe2 #xe3 #xe4 #xe5 #xe6 nil ; #xe0-#xe7 nil #xe9 nil #xeb nil #xed #xee #xef ; #xe8-#xef #xf0 nil nil #xf3 #xf4 #xf5 #xf6 nil ; #xf0-#xf7 #xf8 nil #xfa #xfb #xfc #xfd #xfe nil ; #xf8-#xff #xc0 #xe0 nil nil #xa1 #xb1 nil nil ; #x100-#x107 nil nil nil nil #xc8 #xe8 nil nil ; #x108-#x10f #xa9 #xb9 #xa2 #xb2 nil nil #xcc #xec ; #x110-#x117 #xca #xea nil nil nil nil nil nil ; #x118-#x11f nil nil #xa3 #xb3 nil nil nil nil ; #x120-#x127 #xa5 #xb5 #xa4 #xb4 nil nil #xc7 #xe7 ; #x128-#x12f nil nil nil nil nil nil #xa6 #xb6 ; #x130-#x137 #xff nil nil #xa8 #xb8 nil nil nil ; #x138-#x13f nil nil nil nil nil #xd1 #xf1 nil ; #x140-#x147 nil nil #xaf #xbf #xd2 #xf2 nil nil ; #x148-#x14f nil nil nil nil nil nil nil nil ; #x150-#x157 nil nil nil nil nil nil nil nil ; #x158-#x15f #xaa #xba nil nil nil nil #xab #xbb ; #x160-#x167 #xd7 #xf7 #xae #xbe nil nil nil nil ; #x168-#x16f nil nil #xd9 #xf9 nil nil nil nil ; #x170-#x177 nil nil nil nil nil #xac #xbc nil) ; #x178-#x17f :test #'equalp) (define-unibyte-encoder :iso-8859-10 (code) (or (cond ((< code #xa0) code) ((< code #x180) (svref +unicode-a0-180-to-iso-8859-10+ (the ub8 (- code #xa0)))) ;; Horizontal bar ((= code #x2015) #xbd)) (handle-error))) (define-constant +iso-8859-10-to-unicode+ #(;; #xa0 #x00a0 #x0104 #x0112 #x0122 #x012a #x0128 #x0136 #x00a7 #x013b #x0110 #x0160 #x0166 #x017d #x00ad #x016a #x014a ;; #xb0 #x00b0 #x0105 #x0113 #x0123 #x012b #x0129 #x0137 #x00b7 #x013c #x0111 #x0161 #x0167 #x017e #x2015 #x016b #x014b ;; #xc0 #x0100 #x00c1 #x00c2 #x00c3 #x00c4 #x00c5 #x00c6 #x012e #x010c #x00c9 #x0118 #x00cb #x0116 #x00cd #x00ce #x00cf ;; #xd0 #x00d0 #x0145 #x014c #x00d3 #x00d4 #x00d5 #x00d6 #x0168 #x00d8 #x0172 #x00da #x00db #x00dc #x00dd #x00de #x00df ;; #xe0 #x0101 #x00e1 #x00e2 #x00e3 #x00e4 #x00e5 #x00e6 #x012f #x010d #x00e9 #x0119 #x00eb #x0117 #x00ed #x00ee #x00ef ;; #xf0 #x00f0 #x0146 #x014d #x00f3 #x00f4 #x00f5 #x00f6 #x0169 #x00f8 #x0173 #x00fa #x00fb #x00fc #x00fd #x00fe #x0138) :test #'equalp) (define-unibyte-decoder :iso-8859-10 (octet) (if (< octet #xa0) octet (svref +iso-8859-10-to-unicode+ (the ub8 (- octet #xa0))))) (define-character-encoding :iso-8859-11 "An 8-bit, fixed-width character encoding in which codes #x00-#x9f map to their Unicode equivalents and other codes map to other Unicode character values. Intended to provide most characters found the Thai alphabet." :aliases '() :literal-char-code-limit #xa0) (define-unibyte-encoder :iso-8859-11 (code) (cond ((< code #xa1) code) ((and (<= #xe01 code #xe5b) (not (<= #xe3b code #xe3e)) (not (<= #xe5c code #xe5f))) (- code #xd60)) (t (handle-error)))) (define-unibyte-decoder :iso-8859-11 (octet) (cond ((<= octet #xa0) octet) ((or (<= #xdb octet #xde) (<= #xfc octet #xff)) #xfffd) ((<= octet #xfb) (+ octet #x0d60)) (t (handle-error)))) ;;; There is no iso-8859-12 encoding. (define-character-encoding :iso-8859-13 "An 8-bit, fixed-width character encoding in which codes #x00-#x9f map to their Unicode equivalents and other codes map to other Unicode character values. Intended to provide most characters found in Baltic alphabets." :aliases '() :literal-char-code-limit #xa0) (define-constant +unicode-a0-180-to-iso-8859-13+ #(#xa0 nil #xa2 #xa3 #xa4 nil #xa6 #xa7 ; #xa0-#xa7 nil #xa9 nil #xab #xac #xad #xae nil ; #xa8-#xaf #xb0 #xb1 #xb2 #xb3 nil #xb5 #xb6 #xb7 ; #xb0-#xb7 nil #xb9 nil #xbb #xbc #xbd #xbe nil ; #xb8-#xbf nil nil nil nil #xc4 #xc5 #xaf nil ; #xc0-#xc7 nil #xc9 nil nil nil nil nil nil ; #xc8-#xcf nil nil nil #xd3 nil #xd5 #xd6 #xd7 ; #xd0-#xd7 #xa8 nil nil nil #xdc nil nil #xdf ; #xd8-#xdf nil nil nil nil #xe4 #xe5 #xbf nil ; #xe0-#xe7 nil #xe9 nil nil nil nil nil nil ; #xe8-#xef nil nil nil #xf3 nil #xf5 #xf6 #xf7 ; #xf0-#xf7 #xb8 nil nil nil #xfc nil nil nil ; #xf8-#xff #xc2 #xe2 nil nil #xc0 #xe0 #xc3 #xe3 ; #x100-#x107 nil nil nil nil #xc8 #xe8 nil nil ; #x108-#x10f nil nil #xc7 #xe7 nil nil #xcb #xeb ; #x110-#x117 #xc6 #xe6 nil nil nil nil nil nil ; #x118-#x11f nil nil #xcc #xec nil nil nil nil ; #x120-#x127 nil nil #xce #xee nil nil #xc1 #xe1 ; #x128-#x12f nil nil nil nil nil nil #xcd #xed ; #x130-#x137 nil nil nil #xcf #xef nil nil nil ; #x138-#x13f nil #xd9 #xf9 #xd1 #xf1 #xd2 #xf2 nil ; #x140-#x147 nil nil nil nil #xd4 #xf4 nil nil ; #x148-#x14f nil nil nil nil nil nil #xaa #xba ; #x150-#x157 nil nil #xda #xfa nil nil nil nil ; #x158-#x15f #xd0 #xf0 nil nil nil nil nil nil ; #x160-#x167 nil nil #xdb #xfb nil nil nil nil ; #x168-#x16f nil nil #xd8 #xf8 nil nil nil nil ; #x170-#x177 nil #xca #xea #xdd #xfd #xde #xfe nil) ; #x178-#x17f :test #'equalp) (define-constant +unicode-2018-2020-to-iso-8859-13+ #(nil #xff nil nil #xb4 #xa1 #xa5 nil) ; #x2018-#x201f :test #'equalp) (define-unibyte-encoder :iso-8859-13 (code) (or (cond ((< code #xa0) code) ((< code #x180) (svref +unicode-a0-180-to-iso-8859-13+ (the ub8 (- code #xa0)))) ((<= #x2018 code #x201f) (svref +unicode-2018-2020-to-iso-8859-13+ (the ub8 (- code #x2018))))) (handle-error))) (define-constant +iso-8859-13-to-unicode+ #(;; #xa0 #x00a0 #x201d #x00a2 #x00a3 #x00a4 #x201e #x00a6 #x00a7 #x00d8 #x00a9 #x0156 #x00ab #x00ac #x00ad #x00ae #x00c6 ;; #xb0 #x00b0 #x00b1 #x00b2 #x00b3 #x201c #x00b5 #x00b6 #x00b7 #x00f8 #x00b9 #x0157 #x00bb #x00bc #x00bd #x00be #x00e6 ;; #xc0 #x0104 #x012e #x0100 #x0106 #x00c4 #x00c5 #x0118 #x0112 #x010c #x00c9 #x0179 #x0116 #x0122 #x0136 #x012a #x013b ;; #xd0 #x0160 #x0143 #x0145 #x00d3 #x014c #x00d5 #x00d6 #x00d7 #x0172 #x0141 #x015a #x016a #x00dc #x017b #x017d #x00df ;; #xe0 #x0105 #x012f #x0101 #x0107 #x00e4 #x00e5 #x0119 #x0113 #x010d #x00e9 #x017a #x0117 #x0123 #x0137 #x012b #x013c ;; #xf0 #x0161 #x0144 #x0146 #x00f3 #x014d #x00f5 #x00f6 #x00f7 #x0173 #x0142 #x015b #x016b #x00fc #x017c #x017e #x2019) :test #'equalp) (define-unibyte-decoder :iso-8859-13 (octet) (if (< octet #xa0) octet (svref +iso-8859-13-to-unicode+ (the ub8 (- octet #xa0))))) (define-character-encoding :iso-8859-14 "An 8-bit, fixed-width character encoding in which codes #x00-#x9f map to their Unicode equivalents and other codes map to other Unicode character values. Intended to provide most characters found in Celtic languages." :aliases '(:latin-8 :latin8) :literal-char-code-limit #xa0) (define-constant +unicode-a0-100-to-iso-8859-14+ #(#xa0 nil nil #xa3 nil nil nil #xa7 ; #xa0-#xa7 nil #xa9 nil nil nil #xad #xae nil ; #xa8-#xaf nil nil nil nil nil nil #xb6 nil ; #xb0-#xb7 nil nil nil nil nil nil nil nil ; #xb8-#xbf #xc0 #xc1 #xc2 #xc3 #xc4 #xc5 #xc6 #xc7 ; #xc0-#xc7 #xc8 #xc9 #xca #xcb #xcc #xcd #xce #xcf ; #xc8-#xcf nil #xd1 #xd2 #xd3 #xd4 #xd5 #xd6 nil ; #xd0-#xd7 #xd8 #xd9 #xda #xdb #xdc #xdd nil #xdf ; #xd8-#xdf #xe0 #xe1 #xe2 #xe3 #xe4 #xe5 #xe6 #xe7 ; #xe0-#xe7 #xe8 #xe9 #xea #xeb #xec #xed #xee #xef ; #xe8-#xef nil #xf1 #xf2 #xf3 #xf4 #xf5 #xf6 nil ; #xf0-#xf7 #xf8 #xf9 #xfa #xfb #xfc #xfd nil #xff) ; #xf8-#xff :test #'equalp) (define-constant +unicode-108-128-to-iso-8859-14+ #(nil nil #xa4 #xa5 nil nil nil nil ; #x108-#x10f nil nil nil nil nil nil nil nil ; #x110-#x117 nil nil nil nil nil nil nil nil ; #x118-#x11f #xb2 #xb3 nil nil nil nil nil nil) ; #x120-#x127 :test #'equalp) (define-constant +unicode-170-180-to-iso-8859-14+ #(nil nil nil nil #xd0 #xf0 #xde #xfe ; #x170-#x177 #xaf nil nil nil nil nil nil nil) ; #x178-#x17f :test #'equalp) (define-constant +unicode-1e00-1e88-to-iso-8859-14+ #(nil nil #xa1 #xa2 nil nil nil nil ; #x1e00-#x1e07 nil nil #xa6 #xab nil nil nil nil ; #x1e08-#x1e0f nil nil nil nil nil nil nil nil ; #x1e10-#x1e17 nil nil nil nil nil nil #xb0 #xb1 ; #x1e18-#x1e1f nil nil nil nil nil nil nil nil ; #x1e20-#x1e27 nil nil nil nil nil nil nil nil ; #x1e28-#x1e2f nil nil nil nil nil nil nil nil ; #x1e30-#x1e37 nil nil nil nil nil nil nil nil ; #x1e38-#x1e3f #xb4 #xb5 nil nil nil nil nil nil ; #x1e40-#x1e47 nil nil nil nil nil nil nil nil ; #x1e48-#x1e4f nil nil nil nil nil nil #xb7 #xb9 ; #x1e50-#x1e57 nil nil nil nil nil nil nil nil ; #x1e58-#x1e5f #xbb #xbf nil nil nil nil nil nil ; #x1e60-#x1e67 nil nil #xd7 #xf7 nil nil nil nil ; #x1e68-#x1e6f nil nil nil nil nil nil nil nil ; #x1e70-#x1e77 nil nil nil nil nil nil nil nil ; #x1e78-#x1e7f #xa8 #xb8 #xaa #xba #xbd #xbe nil nil) ; #x1e80-#x1e87 :test #'equalp) (define-constant +unicode-1ef0-1ef8-to-iso-8859-14+ #(nil nil #xac #xbc nil nil nil nil) ; #x1ef0-#x1ef7 :test #'equalp) (define-unibyte-encoder :iso-8859-14 (code) (or (cond ((< code #xa0) code) ((< code #x100) (svref +unicode-a0-100-to-iso-8859-14+ (the ub8 (- code #xa0)))) ((<= #x108 code #x127) (svref +unicode-108-128-to-iso-8859-14+ (the ub8 (- code #x108)))) ((<= #x170 code #x17f) (svref +unicode-170-180-to-iso-8859-14+ (the ub8 (- code #x170)))) ((<= #x1e00 code #x1e87) (svref +unicode-1e00-1e88-to-iso-8859-14+ (the ub8 (- code #x1e00)))) ((<= #x1ef0 code #x1ef7) (svref +unicode-1ef0-1ef8-to-iso-8859-14+ (the ub8 (- code #x1ef0))))) (handle-error))) (define-constant +iso-8859-14-to-unicode+ #(;; #xa0 #x00a0 #x1e02 #x1e03 #x00a3 #x010a #x010b #x1e0a #x00a7 #x1e80 #x00a9 #x1e82 #x1e0b #x1ef2 #x00ad #x00ae #x0178 ;; #xb0 #x1e1e #x1e1f #x0120 #x0121 #x1e40 #x1e41 #x00b6 #x1e56 #x1e81 #x1e57 #x1e83 #x1e60 #x1ef3 #x1e84 #x1e85 #x1e61 ;; #xc0 #x00c0 #x00c1 #x00c2 #x00c3 #x00c4 #x00c5 #x00c6 #x00c7 #x00c8 #x00c9 #x00ca #x00cb #x00cc #x00cd #x00ce #x00cf ;; #xd0 #x0174 #x00d1 #x00d2 #x00d3 #x00d4 #x00d5 #x00d6 #x1e6a #x00d8 #x00d9 #x00da #x00db #x00dc #x00dd #x0176 #x00df ;; #xe0 #x00e0 #x00e1 #x00e2 #x00e3 #x00e4 #x00e5 #x00e6 #x00e7 #x00e8 #x00e9 #x00ea #x00eb #x00ec #x00ed #x00ee #x00ef ;; #xf0 #x0175 #x00f1 #x00f2 #x00f3 #x00f4 #x00f5 #x00f6 #x1e6b #x00f8 #x00f9 #x00fa #x00fb #x00fc #x00fd #x0177 #x00ff) :test #'equalp) (define-unibyte-decoder :iso-8859-14 (octet) (if (< octet #xa0) octet (svref +iso-8859-14-to-unicode+ (the ub8 (- octet #xa0))))) (define-character-encoding :iso-8859-15 "An 8-bit, fixed-width character encoding in which codes #x00-#x9f map to their Unicode equivalents and other codes map to other Unicode character values. Intended to provide most characters found in Western European languages (including the Euro sign and some other characters missing from ISO-8859-1." :aliases '(:latin-9 :latin9) :literal-char-code-limit #xa0) (define-constant +unicode-a0-100-to-iso-8859-15+ #(#xa0 #xa1 #xa2 #xa3 nil #xa5 nil #xa7 ; #xa0-#xa7 nil #xa9 #xaa #xab #xac #xad #xae #xaf ; #xa8-#xaf #xb0 #xb1 #xb2 #xb3 nil #xb5 #xb6 #xb7 ; #xb0-#xb7 nil #xb9 #xba #xbb nil nil nil #xbf ; #xb8-0xbf #xc0 #xc1 #xc2 #xc3 #xc4 #xc5 #xc6 #xc7 ; #xc0-#xc7 #xc8 #xc9 #xca #xcb #xcc #xcd #xce #xcf ; #xc8-#xcf #xd0 #xd1 #xd2 #xd3 #xd4 #xd5 #xd6 #xd7 ; #xd0-#xd7 #xd8 #xd9 #xda #xdb #xdc #xdd #xde #xdf ; #xd8-#xdf #xe0 #xe1 #xe2 #xe3 #xe4 #xe5 #xe6 #xe7 ; #xe0-#xe7 #xe8 #xe9 #xea #xeb #xec #xed #xee #xef ; #xe8-#xef #xf0 #xf1 #xf2 #xf3 #xf4 #xf5 #xf6 #xf7 ; #xf0-#xf7 #xf8 #xf9 #xfa #xfb #xfc #xfd #xfe #xff) ; #xf8-#xff :test #'equalp) (define-constant +unicode-150-180-to-iso-8859-15+ #(nil nil #xbc #xbd nil nil nil nil ; #x150-#x157 nil nil nil nil nil nil nil nil ; #x158-#x15f #xa6 #xa8 nil nil nil nil nil nil ; #x160-#x167 nil nil nil nil nil nil nil nil ; #x168-#x16f nil nil nil nil nil nil nil nil ; #x170-#x177 #xbe nil nil nil nil #xb4 #xb8 nil) ; #x178-#x17f :test #'equalp) (define-unibyte-encoder :iso-8859-15 (code) (or (cond ((< code #xa0) code) ((< code #x100) (svref +unicode-a0-100-to-iso-8859-15+ (the ub8 (- code #xa0)))) ((<= #x150 code #x1f7) (svref +unicode-150-180-to-iso-8859-15+ (the ub8 (- code #x150)))) ;; Euro sign ((= code #x20ac) #xa4)) (handle-error))) (define-constant +iso-8859-15-to-unicode+ #(;; #xa0 #x00a0 #x00a1 #x00a2 #x00a3 #x20ac #x00a5 #x0160 #x00a7 #x0161 #x00a9 #x00aa #x00ab #x00ac #x00ad #x00ae #x00af ;; #xb0 #x00b0 #x00b1 #x00b2 #x00b3 #x017d #x00b5 #x00b6 #x00b7 #x017e #x00b9 #x00ba #x00bb #x0152 #x0153 #x0178 #x00bf ;; #xc0 #x00c0 #x00c1 #x00c2 #x00c3 #x00c4 #x00c5 #x00c6 #x00c7 ;; #xc8 #x00c8 #x00c9 #x00ca #x00cb #x00cc #x00cd #x00ce #x00cf ;; #xd0 #x00d0 #x00d1 #x00d2 #x00d3 #x00d4 #x00d5 #x00d6 #x00d7 ;; #xd8 #x00d8 #x00d9 #x00da #x00db #x00dc #x00dd #x00de #x00df ;; #xe0 #x00e0 #x00e1 #x00e2 #x00e3 #x00e4 #x00e5 #x00e6 #x00e7 ;; #xe8 #x00e8 #x00e9 #x00ea #x00eb #x00ec #x00ed #x00ee #x00ef ;; #xf0 #x00f0 #x00f1 #x00f2 #x00f3 #x00f4 #x00f5 #x00f6 #x00f7 ;; #xf8 #x00f8 #x00f9 #x00fa #x00fb #x00fc #x00fd #x00fe #x00ff) :test #'equalp) (define-unibyte-decoder :iso-8859-15 (octet) (if (< octet #xa0) octet (svref +iso-8859-15-to-unicode+ (the ub8 (- octet #xa0))))) (define-character-encoding :iso-8859-16 "An 8-bit, fixed-width character encoding in which codes #x00-#x9f map to their Unicode equivalents and other codes map to other Unicode character values. Intended to provide most characters found in Southeast European languages." :aliases '(:latin-10 :latin10) :literal-char-code-limit #xa0) (define-constant +unicode-a0-180-to-iso-8859-16+ #(#xa0 nil nil nil nil nil nil #xa7 ; #xa0-#xa7 nil #xa9 nil #xab nil #xad nil nil ; #xa8-#xaf #xb0 #xb1 nil nil nil nil #xb6 #xb7 ; #xb0-#xb7 nil nil nil #xbb nil nil nil nil ; #xb8-#xbf #xc0 #xc1 #xc2 nil #xc4 nil #xc6 #xc7 ; #xc0-#xc7 #xc8 #xc9 #xca #xcb #xcc #xcd #xce #xcf ; #xc8-#xcf nil nil #xd2 #xd3 #xd4 nil #xd6 nil ; #xd0-#xd7 nil #xd9 #xda #xdb #xdc nil nil #xdf ; #xd8-#xdf #xe0 #xe1 #xe2 nil #xe4 nil #xe6 #xe7 ; #xe0-#xe7 #xe8 #xe9 #xea #xeb #xec #xed #xee #xef ; #xe8-#xef nil nil #xf2 #xf3 #xf4 nil #xf6 nil ; #xf0-#xf7 nil #xf9 #xfa #xfb #xfc nil nil #xff ; #xf8-#xff nil nil #xc3 #xe3 #xa1 #xa2 #xc5 #xe5 ; #x100-#x107 nil nil nil nil #xb2 #xb9 nil nil ; #x108-#x10f #xd0 #xf0 nil nil nil nil nil nil ; #x110-#x117 #xdd #xfd nil nil nil nil nil nil ; #x118-#x11f nil nil nil nil nil nil nil nil ; #x120-#x127 nil nil nil nil nil nil nil nil ; #x128-#x12f nil nil nil nil nil nil nil nil ; #x130-#x137 nil nil nil nil nil nil nil nil ; #x138-#x13f nil #xa3 #xb3 #xd1 #xf1 nil nil nil ; #x140-#x147 nil nil nil nil nil nil nil nil ; #x148-#x14f #xd5 #xf5 #xbc #xbd nil nil nil nil ; #x150-#x157 nil nil #xd7 #xf7 nil nil nil nil ; #x158-#x15f #xa6 #xa8 nil nil nil nil nil nil ; #x160-#x167 nil nil nil nil nil nil nil nil ; #x168-#x16f #xd8 #xf8 nil nil nil nil nil nil ; #x170-#x177 #xbe #xac #xae #xaf #xbf #xb4 #xb8 nil) ; #x178-#x17f :test #'equalp) (define-constant +unicode-218-220-to-iso-8859-16+ #(#xaa #xba #xde #xfe nil nil nil nil) ; #x218-#x21f :test #'equalp) (define-constant +unicode-2018-2020-to-iso-8859-16+ #(nil nil nil nil nil #xb5 #xa5 nil) ; #x2018-#x201f :test #'equalp) (define-unibyte-encoder :iso-8859-16 (code) (or (cond ((< code #xa0) code) ((< code #x180) (svref +unicode-a0-180-to-iso-8859-16+ (the ub8 (- code #xa0)))) ((<= #x218 code #x21f) (svref +unicode-218-220-to-iso-8859-16+ (the ub8 (- code #x218)))) ((< #x2018 code #x201f) (svref +unicode-2018-2020-to-iso-8859-16+ (the ub8 (- code #x2018)))) ;; Euro sign ((= code #x20ac) #xa4)) (handle-error))) (define-constant +iso-8859-16-to-unicode+ #(;; #xa0 #x00a0 #x0104 #x0105 #x0141 #x20ac #x201e #x0160 #x00a7 #x0161 #x00a9 #x0218 #x00ab #x0179 #x00ad #x017a #x017b ;; #xb0 #x00b0 #x00b1 #x010c #x0142 #x017d #x201d #x00b6 #x00b7 #x017e #x010d #x0219 #x00bb #x0152 #x0153 #x0178 #x017c ;; #xc0 #x00c0 #x00c1 #x00c2 #x0102 #x00c4 #x0106 #x00c6 #x00c7 #x00c8 #x00c9 #x00ca #x00cb #x00cc #x00cd #x00ce #x00cf ;; #xd0 #x0110 #x0143 #x00d2 #x00d3 #x00d4 #x0150 #x00d6 #x015a #x0170 #x00d9 #x00da #x00db #x00dc #x0118 #x021a #x00df ;; #xe0 #x00e0 #x00e1 #x00e2 #x0103 #x00e4 #x0107 #x00e6 #x00e7 #x00e8 #x00e9 #x00ea #x00eb #x00ec #x00ed #x00ee #x00ef ;; #xf0 #x0111 #x0144 #x00f2 #x00f3 #x00f4 #x0151 #x00f6 #x015b #x0171 #x00f9 #x00fa #x00fb #x00fc #x0119 #x021b #x00ff) :test #'equalp) (define-unibyte-decoder :iso-8859-16 (octet) (if (< octet #xa0) octet (svref +iso-8859-16-to-unicode+ (the ub8 (- octet #xa0)))))

Common Lisp

.lisp

cac-t-u-s/om-sharp

GPL-3.0

9/19/2024, 11:25:22 AM (Europe/Amsterdam)

06ce50fe94c36666c5b470391c9444e9b0bd6dafaa75b00927e32d6b93402aa0

enc-ascii.lisp

cac-t-u-s_om-sharp/src/api/foreign-interface/ffi/babel/src/enc-ascii.lisp

;;;; -*- Mode: lisp; indent-tabs-mode: nil -*- ;;; ;;; enc-ascii.lisp --- Implementation of the ASCII character encoding. ;;; ;;; Copyright (C) 2007, Luis Oliveira <[email protected]> ;;; ;;; Permission is hereby granted, free of charge, to any person ;;; obtaining a copy of this software and associated documentation ;;; files (the "Software"), to deal in the Software without ;;; restriction, including without limitation the rights to use, copy, ;;; modify, merge, publish, distribute, sublicense, and/or sell copies ;;; of the Software, and to permit persons to whom the Software is ;;; furnished to do so, subject to the following conditions: ;;; ;;; The above copyright notice and this permission notice shall be ;;; included in all copies or substantial portions of the Software. ;;; ;;; THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, ;;; EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF ;;; MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND ;;; NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT ;;; HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, ;;; WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, ;;; OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER ;;; DEALINGS IN THE SOFTWARE. (in-package #:babel-encodings) (define-character-encoding :ascii "A 7-bit, fixed-width character encoding in which all character codes map to their Unicode equivalents." :aliases '(:us-ascii) :literal-char-code-limit 128) (define-unibyte-encoder :ascii (code) (if (>= code 128) (handle-error) code)) (define-unibyte-decoder :ascii (octet) (if (>= octet 128) (handle-error) octet))

Common Lisp

.lisp

cac-t-u-s/om-sharp

GPL-3.0

9/19/2024, 11:25:22 AM (Europe/Amsterdam)

d48bd805aeff62d352efccce723fe2dc593fa61ff00eb66336bf8328f9271735

streams.lisp

cac-t-u-s_om-sharp/src/api/foreign-interface/ffi/babel/src/streams.lisp

;;;; -*- Mode: lisp; indent-tabs-mode: nil -*- ;;; ;;; streams.lisp --- Conversions between strings and UB8 vectors. ;;; ;;; Copyright (c) 2005-2007, Dr. Edmund Weitz. All rights reserved. ;;; Copyright (c) 2008, Attila Lendvai. All rights reserved. ;;; ;;; Redistribution and use in source and binary forms, with or without ;;; modification, are permitted provided that the following conditions ;;; are met: ;;; ;;; * Redistributions of source code must retain the above copyright ;;; notice, this list of conditions and the following disclaimer. ;;; ;;; * Redistributions in binary form must reproduce the above ;;; copyright notice, this list of conditions and the following ;;; disclaimer in the documentation and/or other materials ;;; provided with the distribution. ;;; ;;; THIS SOFTWARE IS PROVIDED BY THE AUTHOR 'AS IS' AND ANY EXPRESSED ;;; OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED ;;; WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ;;; ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY ;;; DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL ;;; DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE ;;; GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS ;;; INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, ;;; WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING ;;; NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS ;;; SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ;;; STATUS ;;; ;;; - in-memory output streams support binary/bivalent/character ;;; element-types and file-position ;;; TODO ;;; ;;; - filter-stream types/mixins that can wrap a binary stream and ;;; turn it into a bivalent/character stream ;;; - in-memory input streams with file-position similar to in-memory ;;; output streams ;;; - in-memory input/output streams? (in-package #:babel) (defpackage #:babel-streams (:use #:common-lisp #:babel #:trivial-gray-streams #:alexandria) (:export #:in-memory-stream #:vector-output-stream #:vector-input-stream #:make-in-memory-output-stream #:make-in-memory-input-stream #:get-output-stream-sequence #:with-output-to-sequence #:with-input-from-sequence)) (in-package :babel-streams) (declaim (inline check-if-open check-if-accepts-octets check-if-accepts-characters stream-accepts-characters? stream-accepts-octets? vector-extend extend-vector-output-stream-buffer)) (defgeneric get-output-stream-sequence (stream &key &allow-other-keys)) ;;;; Some utilities (on top due to inlining) (defun vector-extend (extension vector &key (start 0) (end (length extension))) ;; copied over from cl-quasi-quote (declare (optimize speed) (type vector extension vector) (type array-index start end)) (let* ((original-length (length vector)) (extension-length (- end start)) (new-length (+ original-length extension-length)) (original-dimension (array-dimension vector 0))) (when (< original-dimension new-length) (setf vector (adjust-array vector (max (* 2 original-dimension) new-length)))) (setf (fill-pointer vector) new-length) (replace vector extension :start1 original-length :start2 start :end2 end) vector)) (defclass in-memory-stream (trivial-gray-stream-mixin) ((element-type ; :default means bivalent :initform :default :initarg :element-type :accessor element-type-of) (external-format :initform (ensure-external-format *default-character-encoding*) :initarg :external-format :accessor external-format-of) #+cmu (open-p :initform t :accessor in-memory-stream-open-p :documentation "For CMUCL we have to keep track of this manually.")) (:documentation "An IN-MEMORY-STREAM is a binary stream that reads octets from or writes octets to a sequence in RAM.")) (defmethod stream-element-type ((self in-memory-stream)) ;; stream-element-type is a CL symbol, we may not install an accessor on it. ;; so, go through this extra step. (element-type-of self)) (defun stream-accepts-octets? (stream) (let ((element-type (element-type-of stream))) (or (eq element-type :default) (equal element-type '(unsigned-byte 8)) (subtypep element-type '(unsigned-byte 8))))) (defun stream-accepts-characters? (stream) (let ((element-type (element-type-of stream))) (member element-type '(:default character base-char)))) (defclass in-memory-input-stream (in-memory-stream fundamental-binary-input-stream) () (:documentation "An IN-MEMORY-INPUT-STREAM is a binary stream that reads octets from a sequence in RAM.")) #+cmu (defmethod output-stream-p ((stream in-memory-input-stream)) "Explicitly states whether this is an output stream." (declare (optimize speed)) nil) (defclass in-memory-output-stream (in-memory-stream fundamental-binary-output-stream) () (:documentation "An IN-MEMORY-OUTPUT-STREAM is a binary stream that writes octets to a sequence in RAM.")) #+cmu (defmethod input-stream-p ((stream in-memory-output-stream)) "Explicitly states whether this is an input stream." (declare (optimize speed)) nil) (defun make-in-memory-output-stream (&key (element-type :default) external-format initial-buffer-size) "Returns a binary output stream which accepts objects of type ELEMENT-TYPE \(a subtype of OCTET) and makes available a sequence that contains the octes that were actually output." (declare (optimize speed)) (unless external-format (setf external-format *default-character-encoding*)) (when (eq element-type :bivalent) (setf element-type :default)) (make-instance 'vector-output-stream :vector (make-vector-stream-buffer :element-type (cond ((or (eq element-type :default) (equal element-type '(unsigned-byte 8))) '(unsigned-byte 8)) ((eq element-type 'character) 'character) ((subtypep element-type '(unsigned-byte 8)) '(unsigned-byte 8)) (t (error "Illegal element-type ~S" element-type))) :initial-size initial-buffer-size) :element-type element-type :external-format (ensure-external-format external-format))) (defun make-in-memory-input-stream (data &key (element-type :default) external-format) "Returns a binary input stream which provides the elements of DATA when read." (declare (optimize speed)) (unless external-format (setf external-format *default-character-encoding*)) (when (eq element-type :bivalent) (setf element-type :default)) (make-instance 'vector-input-stream :vector data :element-type element-type :end (length data) :external-format (ensure-external-format external-format))) (defclass vector-stream () ((vector :initarg :vector :accessor vector-stream-vector :documentation "The underlying vector of the stream which \(for output) must always be adjustable and have a fill pointer.") (index :initform 0 :initarg :index :accessor vector-stream-index :type (integer 0 #.array-dimension-limit) :documentation "An index into the underlying vector denoting the current position.")) (:documentation "A VECTOR-STREAM is a mixin for IN-MEMORY streams where the underlying sequence is a vector.")) (defclass vector-input-stream (vector-stream in-memory-input-stream) ((end :initarg :end :accessor vector-stream-end :type (integer 0 #.array-dimension-limit) :documentation "An index into the underlying vector denoting the end of the available data.")) (:documentation "A binary input stream that gets its data from an associated vector of octets.")) (defclass vector-output-stream (vector-stream in-memory-output-stream) () (:documentation "A binary output stream that writes its data to an associated vector.")) (define-condition in-memory-stream-error (stream-error) () (:documentation "Superclass for all errors related to IN-MEMORY streams.")) (define-condition in-memory-stream-closed-error (in-memory-stream-error) () (:report (lambda (condition stream) (format stream "~S is closed." (stream-error-stream condition)))) (:documentation "An error that is signalled when someone is trying to read from or write to a closed IN-MEMORY stream.")) (define-condition wrong-element-type-stream-error (stream-error) ((expected-type :accessor expected-type-of :initarg :expected-type)) (:report (lambda (condition output) (let ((stream (stream-error-stream condition))) (format output "The element-type of ~S is ~S while expecting ~ a stream that accepts ~S." stream (element-type-of stream) (expected-type-of condition)))))) (defun wrong-element-type-stream-error (stream expected-type) (error 'wrong-element-type-stream-error :stream stream :expected-type expected-type)) #+cmu (defmethod open-stream-p ((stream in-memory-stream)) "Returns a true value if STREAM is open. See ANSI standard." (declare (optimize speed)) (in-memory-stream-open-p stream)) #+cmu (defmethod close ((stream in-memory-stream) &key abort) "Closes the stream STREAM. See ANSI standard." (declare (ignore abort) (optimize speed)) (prog1 (in-memory-stream-open-p stream) (setf (in-memory-stream-open-p stream) nil))) (defun check-if-open (stream) "Checks if STREAM is open and signals an error otherwise." (declare (optimize speed)) (unless (open-stream-p stream) (error 'in-memory-stream-closed-error :stream stream))) (defun check-if-accepts-octets (stream) (declare (optimize speed)) (unless (stream-accepts-octets? stream) (wrong-element-type-stream-error stream '(unsigned-byte 8)))) (defun check-if-accepts-characters (stream) (declare (optimize speed)) (unless (stream-accepts-characters? stream) (wrong-element-type-stream-error stream 'character))) (defmethod stream-read-byte ((stream vector-input-stream)) "Reads one byte and increments INDEX pointer unless we're beyond END pointer." (declare (optimize speed)) (check-if-open stream) (let ((index (vector-stream-index stream))) (cond ((< index (vector-stream-end stream)) (incf (vector-stream-index stream)) (aref (vector-stream-vector stream) index)) (t :eof)))) #+#:ignore (defmethod stream-read-char ((stream vector-input-stream)) ;; TODO ) (defmethod stream-listen ((stream vector-input-stream)) "Checking whether INDEX is beyond END." (declare (optimize speed)) (check-if-open stream) (< (vector-stream-index stream) (vector-stream-end stream))) (defmethod stream-read-sequence ((stream vector-input-stream) sequence start end &key) (declare (optimize speed) (type array-index start end)) ;; TODO check the sequence type, assert for the element-type and use ;; the external-format. (loop with vector-end of-type array-index = (vector-stream-end stream) with vector = (vector-stream-vector stream) for index from start below end for vector-index of-type array-index = (vector-stream-index stream) while (< vector-index vector-end) do (setf (elt sequence index) (aref vector vector-index)) (incf (vector-stream-index stream)) finally (return index))) (defmethod stream-write-byte ((stream vector-output-stream) byte) "Writes a byte \(octet) by extending the underlying vector." (declare (optimize speed)) (check-if-open stream) (check-if-accepts-octets stream) (vector-push-extend byte (vector-stream-vector stream)) (incf (vector-stream-index stream)) byte) (defun extend-vector-output-stream-buffer (extension stream &key (start 0) (end (length extension))) (declare (optimize speed) (type array-index start end) (type vector extension)) (vector-extend extension (vector-stream-vector stream) :start start :end end) (incf (vector-stream-index stream) (- end start)) (values)) (defmethod stream-write-char ((stream vector-output-stream) char) (declare (optimize speed)) (check-if-open stream) (check-if-accepts-characters stream) ;; TODO this is naiive here, there's room for optimization (let ((octets (string-to-octets (string char) :encoding (external-format-of stream)))) (extend-vector-output-stream-buffer octets stream)) char) (defmethod stream-write-sequence ((stream vector-output-stream) sequence start end &key) "Just calls VECTOR-PUSH-EXTEND repeatedly." (declare (optimize speed) (type array-index start end)) (etypecase sequence (string (if (stream-accepts-octets? stream) ;; TODO this is naiive here, there's room for optimization (let ((octets (string-to-octets sequence :encoding (external-format-of stream) :start start :end end))) (extend-vector-output-stream-buffer octets stream)) (progn (assert (stream-accepts-characters? stream)) (extend-vector-output-stream-buffer sequence stream :start start :end end)))) ((vector (unsigned-byte 8)) ;; specialized branch to help inlining (check-if-accepts-octets stream) (extend-vector-output-stream-buffer sequence stream :start start :end end)) (vector (check-if-accepts-octets stream) (extend-vector-output-stream-buffer sequence stream :start start :end end))) sequence) (defmethod stream-line-column ((stream vector-output-stream)) "Dummy line-column method that always returns NIL. Needed for character output streams." nil) (defmethod stream-file-position ((stream vector-stream)) "Simply returns the index into the underlying vector." (declare (optimize speed)) (vector-stream-index stream)) (defun make-vector-stream-buffer (&key (element-type '(unsigned-byte 8)) initial-size) "Creates and returns an array which can be used as the underlying vector for a VECTOR-OUTPUT-STREAM." (declare (optimize speed) (type (or null array-index) initial-size)) (make-array (the array-index (or initial-size 32)) :adjustable t :fill-pointer 0 :element-type element-type)) (defmethod get-output-stream-sequence ((stream in-memory-output-stream) &key (return-as 'vector)) "Returns a vector containing, in order, all the octets that have been output to the IN-MEMORY stream STREAM. This operation clears any octets on STREAM, so the vector contains only those octets which have been output since the last call to GET-OUTPUT-STREAM-SEQUENCE or since the creation of the stream, whichever occurred most recently. If AS-LIST is true the return value is coerced to a list." (declare (optimize speed)) (prog1 (ecase return-as (vector (vector-stream-vector stream)) (string (octets-to-string (vector-stream-vector stream) :encoding (external-format-of stream))) (list (coerce (vector-stream-vector stream) 'list))) (setf (vector-stream-vector stream) (make-vector-stream-buffer)))) (defmacro with-output-to-sequence ((var &key (return-as ''vector) (element-type '':default) (external-format '*default-character-encoding*) initial-buffer-size) &body body) "Creates an IN-MEMORY output stream, binds VAR to this stream and then executes the code in BODY. The stream stores data of type ELEMENT-TYPE \(a subtype of OCTET). The stream is automatically closed on exit from WITH-OUTPUT-TO-SEQUENCE, no matter whether the exit is normal or abnormal. The return value of this macro is a vector \(or a list if AS-LIST is true) containing the octets that were sent to the stream within BODY." (multiple-value-bind (body declarations) (parse-body body) ;; this is here to stop SBCL complaining about binding them to NIL `(let ((,var (make-in-memory-output-stream :element-type ,element-type :external-format ,external-format :initial-buffer-size ,initial-buffer-size))) ,@declarations (unwind-protect (progn ,@body (get-output-stream-sequence ,var :return-as ,return-as)) (close ,var))))) (defmacro with-input-from-sequence ((var data &key (element-type '':default) (external-format '*default-character-encoding*)) &body body) "Creates an IN-MEMORY input stream that will return the values available in DATA, binds VAR to this stream and then executes the code in BODY. The stream stores data of type ELEMENT-TYPE \(a subtype of OCTET). The stream is automatically closed on exit from WITH-INPUT-FROM-SEQUENCE, no matter whether the exit is normal or abnormal. The return value of this macro is the return value of BODY." (multiple-value-bind (body declarations) (parse-body body) ;; this is here to stop SBCL complaining about binding them to NIL `(let ((,var (make-in-memory-input-stream ,data :element-type ,element-type :external-format ,external-format))) ,@declarations (unwind-protect (progn ,@body) (close ,var)))))

Common Lisp

.lisp

cac-t-u-s/om-sharp

GPL-3.0

9/19/2024, 11:25:22 AM (Europe/Amsterdam)

8315e63da3a7edac28d409c68129bc33db44c026354bd9264e6027c9d3db1f48

enc-unicode.lisp

cac-t-u-s_om-sharp/src/api/foreign-interface/ffi/babel/src/enc-unicode.lisp

;;;; -*- Mode: lisp; indent-tabs-mode: nil -*- ;;; ;;; enc-unicode.lisp --- Unicode encodings. ;;; ;;; Copyright (C) 2007, Luis Oliveira <[email protected]> ;;; ;;; Permission is hereby granted, free of charge, to any person ;;; obtaining a copy of this software and associated documentation ;;; files (the "Software"), to deal in the Software without ;;; restriction, including without limitation the rights to use, copy, ;;; modify, merge, publish, distribute, sublicense, and/or sell copies ;;; of the Software, and to permit persons to whom the Software is ;;; furnished to do so, subject to the following conditions: ;;; ;;; The above copyright notice and this permission notice shall be ;;; included in all copies or substantial portions of the Software. ;;; ;;; THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, ;;; EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF ;;; MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND ;;; NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT ;;; HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, ;;; WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, ;;; OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER ;;; DEALINGS IN THE SOFTWARE. ;;; This implementation is largely based on OpenMCL's l1-unicode.lisp ;;; Copyright (C) 2006 Clozure Associates and contributors. (in-package #:babel-encodings) (eval-when (:compile-toplevel :load-toplevel :execute) (defconstant +repl+ #xfffd "Unicode replacement character code point.") (defconstant +byte-order-mark-code+ #xfeff) (defconstant +swapped-byte-order-mark-code+ #xfffe) (defconstant +swapped-byte-order-mark-code-32+ #xfffe0000)) ;;; Some convenience macros adding FIXNUM declarations. (defmacro f-ash (integer count) `(the fixnum (ash ,integer ,count))) (defmacro f-logior (&rest integers) `(the fixnum (logior ,@integers))) (defmacro f-logand (&rest integers) `(the fixnum (logand ,@integers))) (defmacro f-logxor (&rest integers) `(the fixnum (logxor ,@integers))) ;;;; UTF-8 (define-character-encoding :utf-8 "An 8-bit, variable-length character encoding in which character code points in the range #x00-#x7f can be encoded in a single octet; characters with larger code values can be encoded in 2 to 4 bytes." :max-units-per-char 4 :literal-char-code-limit #x80 :bom-encoding #(#xef #xbb #xbf) :default-replacement #xfffd) (define-condition invalid-utf8-starter-byte (character-decoding-error) () (:documentation "Signalled when an invalid UTF-8 starter byte is found.")) (define-condition invalid-utf8-continuation-byte (character-decoding-error) () (:documentation "Signalled when an invalid UTF-8 continuation byte is found.")) (define-condition overlong-utf8-sequence (character-decoding-error) () (:documentation "Signalled upon overlong UTF-8 sequences.")) (define-octet-counter :utf-8 (getter type) `(named-lambda utf-8-octet-counter (seq start end max) (declare (type ,type seq) (fixnum start end max)) (loop with noctets fixnum = 0 for i fixnum from start below end for code of-type code-point = (,getter seq i) do (let ((new (+ (cond ((< code #x80) 1) ((< code #x800) 2) ((< code #x10000) 3) (t 4)) noctets))) (if (and (plusp max) (> new max)) (loop-finish) (setq noctets new))) finally (return (values noctets i))))) (define-code-point-counter :utf-8 (getter type) `(named-lambda utf-8-code-point-counter (seq start end max) (declare (type ,type seq) (fixnum start end max)) (loop with nchars fixnum = 0 with i fixnum = start while (< i end) do ;; check for invalid continuation bytes (macrolet ((invalid-cb-p (n) `(and (< (+ i ,n) end) (not (< #x7f (,',getter seq (+ i ,n)) #xc0))))) ;; wrote this code with LET instead of FOR because CLISP's ;; LOOP doesn't like WHILE clauses before FOR clauses. (let* ((octet (,getter seq i)) (next-i (+ i (cond ((or (< octet #xc0) (invalid-cb-p 1)) 1) ((or (< octet #xe0) (invalid-cb-p 2)) 2) ((or (< octet #xf0) (invalid-cb-p 3)) 3) ((or (< octet #xf8) (invalid-cb-p 4)) 4) ((or (< octet #xfc) (invalid-cb-p 5)) 5) (t 6))))) (declare (type ub8 octet) (fixnum next-i)) (cond ((> next-i end) ;; Should we add restarts to this error, we'll have ;; to figure out a way to communicate with the ;; decoder since we probably want to do something ;; about it right here when we have a chance to ;; change the count or something. (Like an ;; alternative replacement character or perhaps the ;; existence of this error so that the decoder ;; doesn't have to check for it on every iteration ;; like we do.) ;; ;; FIXME: The data for this error is not right. (decoding-error (vector octet) :utf-8 seq i nil 'end-of-input-in-character) (return (values (1+ nchars) end))) (t (setq nchars (1+ nchars) i next-i) (when (and (plusp max) (= nchars max)) (return (values nchars i))))))) finally (progn (assert (= i end)) (return (values nchars i)))))) (define-encoder :utf-8 (getter src-type setter dest-type) `(named-lambda utf-8-encoder (src start end dest d-start) (declare (type ,src-type src) (type ,dest-type dest) (fixnum start end d-start)) (loop with di fixnum = d-start for i fixnum from start below end for code of-type code-point = (,getter src i) do (macrolet ((set-octet (offset value) `(,',setter ,value dest (the fixnum (+ di ,offset))))) (cond ;; 1 octet ((< code #x80) (set-octet 0 code) (incf di)) ;; 2 octets ((< code #x800) (set-octet 0 (logior #xc0 (f-ash code -6))) (set-octet 1 (logior #x80 (f-logand code #x3f))) (incf di 2)) ;; 3 octets ((< code #x10000) (set-octet 0 (logior #xe0 (f-ash code -12))) (set-octet 1 (logior #x80 (f-logand #x3f (f-ash code -6)))) (set-octet 2 (logior #x80 (f-logand code #x3f))) (incf di 3)) ;; 4 octets (t (set-octet 0 (logior #xf0 (f-logand #x07 (f-ash code -18)))) (set-octet 1 (logior #x80 (f-logand #x3f (f-ash code -12)))) (set-octet 2 (logior #x80 (f-logand #x3f (f-ash code -6)))) (set-octet 3 (logior #x80 (logand code #x3f))) (incf di 4)))) finally (return (the fixnum (- di d-start)))))) (define-decoder :utf-8 (getter src-type setter dest-type) `(named-lambda utf-8-decoder (src start end dest d-start) (declare (type ,src-type src) (type ,dest-type dest) (fixnum start end d-start)) (let ((u2 0) (u3 0) (u4 0) (u5 0) (u6 0)) (declare (type ub8 u2 u3 u4 u5 u6)) (loop for di fixnum from d-start for i fixnum from start below end for u1 of-type ub8 = (,getter src i) do ;; Note: CONSUME-OCTET doesn't check if I is being ;; incremented past END. We're assuming that END has ;; been calculated with the CODE-POINT-POINTER above that ;; checks this. (macrolet ((consume-octet () `(let ((next-i (incf i))) (if (= next-i end) ;; FIXME: data for this error is incomplete. ;; and signalling this error twice (return-from setter-block (decoding-error nil :utf-8 src i +repl+ 'end-of-input-in-character)) (,',getter src next-i)))) (handle-error (n &optional (c 'character-decoding-error)) `(decoding-error (vector ,@(subseq '(u1 u2 u3 u4 u5 u6) 0 n)) :utf-8 src (1+ (- i ,n)) +repl+ ',c)) (handle-error-if-icb (var n) `(when (not (< #x7f ,var #xc0)) (decf i) (return-from setter-block (handle-error ,n invalid-utf8-continuation-byte))))) (,setter (block setter-block (cond ((< u1 #x80) u1) ; 1 octet ((< u1 #xc0) (handle-error 1 invalid-utf8-starter-byte)) (t (setq u2 (consume-octet)) (handle-error-if-icb u2 1) (cond ((< u1 #xc2) (handle-error 2 overlong-utf8-sequence)) ((< u1 #xe0) ; 2 octets (logior (f-ash (f-logand #x1f u1) 6) (f-logxor u2 #x80))) (t (setq u3 (consume-octet)) (handle-error-if-icb u3 2) (cond ((and (= u1 #xe0) (< u2 #xa0)) (handle-error 3 overlong-utf8-sequence)) ((< u1 #xf0) ; 3 octets (let ((start (f-logior (f-ash (f-logand u1 #x0f) 12) (f-ash (f-logand u2 #x3f) 6)))) (if (<= #xd800 start #xdfc0) (handle-error 3 character-out-of-range) (logior start (f-logand u3 #x3f))))) (t ; 4 octets (setq u4 (consume-octet)) (handle-error-if-icb u4 3) (cond ((and (= u1 #xf0) (< u2 #x90)) (handle-error 4 overlong-utf8-sequence)) ((< u1 #xf8) (if (or (> u1 #xf4) (and (= u1 #xf4) (> u2 #x8f))) (handle-error 4 character-out-of-range) (f-logior (f-ash (f-logand u1 7) 18) (f-ash (f-logxor u2 #x80) 12) (f-ash (f-logxor u3 #x80) 6) (f-logxor u4 #x80)))) ;; from here on we'll be getting either ;; invalid continuation bytes or overlong ;; 5-byte or 6-byte sequences. (t (setq u5 (consume-octet)) (handle-error-if-icb u5 4) (cond ((and (= u1 #xf8) (< u2 #x88)) (handle-error 5 overlong-utf8-sequence)) ((< u1 #xfc) (handle-error 5 character-out-of-range)) (t (setq u6 (consume-octet)) (handle-error-if-icb u6 5) (cond ((and (= u1 #xfc) (< u2 #x84)) (handle-error 6 overlong-utf8-sequence)) (t (handle-error 6 character-out-of-range) ))))))))))))) dest di)) finally (return (the fixnum (- di d-start))))))) ;;;; UTF-8B ;;; The following excerpt from a linux-utf8 message by Markus Kuhn is ;;; the closest thing to a UTF-8B specification: ;;; ;;; <http://mail.nl.linux.org/linux-utf8/2000-07/msg00040.html> ;;; ;;; "D) Emit a malformed UTF-16 sequence for every byte in a malformed ;;; UTF-8 sequence ;;; ;;; All the previous options for converting malformed UTF-8 sequences ;;; to UTF-16 destroy information. This can be highly undesirable in ;;; applications such as text file editors, where guaranteed binary ;;; transparency is a desireable feature. (E.g., I frequently edit ;;; executable code or graphic files with the Emacs text editor and I ;;; hate the idea that my editor might automatically make U+FFFD ;;; substitutions at locations that I haven't even edited when I save ;;; the file again.) ;;; ;;; I therefore suggested 1999-11-02 on the unicode@xxxxxxxxxxx ;;; mailing list the following approach. Instead of using U+FFFD, ;;; simply encode malformed UTF-8 sequences as malformed UTF-16 ;;; sequences. Malformed UTF-8 sequences consist excludively of the ;;; bytes 0x80 - 0xff, and each of these bytes can be represented ;;; using a 16-bit value from the UTF-16 low-half surrogate zone ;;; U+DC80 to U+DCFF. Thus, the overlong "K" (U+004B) 0xc1 0x8b from ;;; the above example would be represented in UTF-16 as U+DCC1 ;;; U+DC8B. If we simply make sure that every UTF-8 encoded surrogate ;;; character is also treated like a malformed sequence, then there ;;; is no way that a single high-half surrogate could precede the ;;; encoded malformed sequence and cause a valid UTF-16 sequence to ;;; emerge. ;;; ;;; This way 100% binary transparent UTF-8 -> UTF-16 -> UTF-8 ;;; round-trip compatibility can be achieved quite easily. ;;; ;;; On an output device, a lonely low-half surrogate character should ;;; be treated just like a character outside the adopted subset of ;;; representable characters, that is for the end user, the display ;;; would look exactly like with semantics B), i.e. one symbol per ;;; byte of a malformed sequence. However in contrast to semantics ;;; B), no information is thrown away, and a cut&paste in an editor ;;; or terminal emulator will be guaranteed to reconstruct the ;;; original byte sequence. This should greatly reduce the incidence ;;; of accidental corruption of binary data by UTF-8 -> UTF-16 -> ;;; UTF-8 conversion round trips." (define-character-encoding :utf-8b "An 8-bit, variable-length character encoding in which character code points in the range #x00-#x7f can be encoded in a single octet; characters with larger code values can be encoded in 2 to 4 bytes. Invalid UTF-8 sequences are encoded with #xDCXX code points for each invalid byte." :max-units-per-char 4 :literal-char-code-limit #x80 :bom-encoding #(#xef #xbb #xbf) :default-replacement nil) ;;; TODO: reuse the :UTF-8 octet counter through a simple macro. (define-octet-counter :utf-8b (getter type) `(named-lambda utf-8b-octet-counter (seq start end max) (declare (type ,type seq) (fixnum start end max)) (loop with noctets fixnum = 0 for i fixnum from start below end for code of-type code-point = (,getter seq i) do (let ((new (+ (cond ((< code #x80) 1) ((< code #x800) 2) ((<= #xdc80 code #xdcff) 1) ((< code #x10000) 3) (t 4)) noctets))) (if (and (plusp max) (> new max)) (loop-finish) (setq noctets new))) finally (return (values noctets i))))) (define-code-point-counter :utf-8b (getter type) `(named-lambda utf-8b-code-point-counter (seq start end max) (declare (type ,type seq) (fixnum start end max)) (loop with nchars fixnum = 0 with i fixnum = start while (< i end) do ;; wrote this code with LET instead of FOR because CLISP's ;; LOOP doesn't like WHILE clauses before FOR clauses. (let* ((octet (,getter seq i)) (noctets (cond ((< octet #x80) 1) ((< octet #xe0) 2) ((< octet #xf0) 3) (t 4)))) (declare (type ub8 octet) (fixnum noctets)) (cond ((> (+ i noctets) end) ;; If this error is suppressed these last few bytes ;; will be encoded as raw bytes later. (decoding-error (vector octet) :utf-8 seq i nil 'end-of-input-in-character) (return (values (+ nchars (- end i)) end))) (t ;; FIXME: clean this mess up. (let* ((u1 octet) (u2 (if (>= noctets 2) (,getter seq (1+ i)) 0)) (u3 (if (>= noctets 3) (,getter seq (+ i 2)) 0)) (u4 (if (= noctets 4) (,getter seq (+ i 3)) 0)) (inc (or (and (> noctets 1) (< u1 #xc2)) (and (= noctets 2) (not (logior u2 #x40))) (and (= noctets 3) (not (and (< (f-logxor u2 #x80) #x40) (< (f-logxor u3 #x80) #x40) (or (>= u1 #xe1) (>= u2 #xa0)) (or (/= u1 #xed) (< u2 #xa0) (> u2 #xbf))))) (and (= noctets 4) (not (and (< (f-logxor u2 #x80) #x40) (< (f-logxor u3 #x80) #x40) (< (f-logxor u4 #x80) #x40) (or (>= u1 #xf1) (>= u2 #x90)))))))) (let ((new-nchars (if inc (+ nchars noctets) (1+ nchars)))) (when (and (plusp max) (> new-nchars max)) (return (values nchars i))) (incf i noctets) (setq nchars new-nchars)))))) finally (progn (assert (= i end)) (return (values nchars i)))))) ;;; TODO: reuse the :UTF-8 encoder with through a simple macro. (define-encoder :utf-8b (getter src-type setter dest-type) `(named-lambda utf-8b-encoder (src start end dest d-start) (declare (type ,src-type src) (type ,dest-type dest) (fixnum start end d-start)) (loop with di fixnum = d-start for i fixnum from start below end for code of-type code-point = (,getter src i) do (macrolet ((set-octet (offset value) `(,',setter ,value dest (the fixnum (+ di ,offset))))) (cond ;; 1 octet ((< code #x80) (set-octet 0 code) (incf di)) ;; 2 octets ((< code #x800) (set-octet 0 (logior #xc0 (f-ash code -6))) (set-octet 1 (logior #x80 (f-logand code #x3f))) (incf di 2)) ;; 1 octet (invalid octet) ((<= #xdc80 code #xdcff) (set-octet 0 (f-logand code #xff)) (incf di)) ;; 3 octets ((< code #x10000) (set-octet 0 (logior #xe0 (f-ash code -12))) (set-octet 1 (logior #x80 (f-logand #x3f (f-ash code -6)))) (set-octet 2 (logior #x80 (f-logand code #x3f))) (incf di 3)) ;; 4 octets (t (set-octet 0 (logior #xf0 (f-logand #x07 (f-ash code -18)))) (set-octet 1 (logior #x80 (f-logand #x3f (f-ash code -12)))) (set-octet 2 (logior #x80 (f-logand #x3f (f-ash code -6)))) (set-octet 3 (logand #x3f code)) (incf di 4)))) finally (return (the fixnum (- di d-start)))))) (define-decoder :utf-8b (getter src-type setter dest-type) `(named-lambda utf-8b-decoder (src start end dest d-start) (declare (type ,src-type src) (type ,dest-type dest) (fixnum start end d-start)) (let ((u2 0) (u3 0) (u4 0)) (declare (type ub8 u2 u3 u4)) (loop for di fixnum from d-start for i fixnum from start below end for u1 of-type ub8 = (,getter src i) do ;; Unlike the UTF-8 version, this version of ;; CONSUME-OCTET needs to check if I is being incremented ;; past END because we might have trailing binary ;; garbage. (macrolet ((consume-octet (n) `(if (= i (1- end)) (encode-raw-octets ,n) (,',getter src (incf i)))) (encode-raw-octets (n) `(progn ,@(loop for i below n and var in '(u1 u2 u3 u4) collect `(,',setter (logior #xdc00 ,var) dest di) unless (= i (1- n)) collect '(incf di)) (return-from set-body)))) (block set-body (,setter (cond ((< u1 #x80) ; 1 octet u1) ((>= u1 #xc2) (setq u2 (consume-octet 1)) (cond ((< u1 #xe0) ; 2 octets (if (< (f-logxor u2 #x80) #x40) (logior (f-ash (f-logand #x1f u1) 6) (f-logxor u2 #x80)) (encode-raw-octets 2))) (t (setq u3 (consume-octet 2)) (cond ((< u1 #xf0) ; 3 octets (if (and (< (f-logxor u2 #x80) #x40) (< (f-logxor u3 #x80) #x40) (or (>= u1 #xe1) (>= u2 #xa0))) (let ((start (f-logior (f-ash (f-logand u1 #x0f) 12) (f-ash (f-logand u2 #x3f) 6)))) (if (<= #xd800 start #xdfc0) (encode-raw-octets 3) (logior start (f-logand u3 #x3f)))) (encode-raw-octets 3))) (t ; 4 octets (setq u4 (consume-octet 3)) (if (and (< (f-logxor u2 #x80) #x40) (< (f-logxor u3 #x80) #x40) (< (f-logxor u4 #x80) #x40) (or (>= u1 #xf1) (>= u2 #x90))) (logior (f-logior (f-ash (f-logand u1 7) 18) (f-ash (f-logxor u2 #x80) 12)) (f-logior (f-ash (f-logxor u3 #x80) 6) (f-logxor u4 #x80))) (encode-raw-octets 4))))))) (t (encode-raw-octets 1))) dest di))) finally (return (the fixnum (- di d-start))))))) ;;;; UTF-16 ;;; TODO: add a way to pass some info at compile-time telling us that, ;;; for example, the maximum code-point will always be < #x10000 in ;;; which case we could simply return (* 2 (- end start)). (defmacro utf16-octet-counter (getter type) `(named-lambda utf-16-octet-counter (seq start end max) (declare (type ,type seq) (fixnum start end max)) (loop with noctets fixnum = 0 for i fixnum from start below end for code of-type code-point = (,getter seq i) do (let ((new (the fixnum (+ (if (< code #x10000) 2 4) noctets)))) (if (and (plusp max) (> new max)) (loop-finish) (setq noctets new))) finally (return (values noctets i))))) (defmacro utf-16-combine-surrogate-pairs (u1 u2) `(the (unsigned-byte 21) (+ #x10000 (the (unsigned-byte 20) (logior (the (unsigned-byte 20) (ash (the (unsigned-byte 10) (- ,u1 #xd800)) 10)) (the (unsigned-byte 10) (- ,u2 #xdc00))))))) (defmacro define-utf-16 (name &optional endianness) (check-type endianness (or null (eql :be) (eql :le))) (check-type name keyword) (let ((swap-var (gensym "SWAP")) (code-point-counter-name (format-symbol t '#:~a-code-point-counter (string name))) (encoder-name (format-symbol t '#:~a-encoder (string name))) (decoder-name (format-symbol t '#:~a-decoder (string name)))) (labels ((make-bom-check-form (end start getter seq) (if (null endianness) ``((,',swap-var (when (> ,,end ,,start) (case (,,getter ,,seq ,,start 2 :ne) (#.+byte-order-mark-code+ (incf ,,start 2) nil) (#.+swapped-byte-order-mark-code+ (incf ,,start 2) t) (t #+little-endian t))))) '())) (make-getter-form (getter src i) (case endianness (:le ``(,,getter ,,src ,,i 2 :le)) (:be ``(,,getter ,,src ,,i 2 :be)) (t ``(if ,',swap-var (,,getter ,,src ,,i 2 :re) (,,getter ,,src ,,i 2 :ne))))) (make-setter-form (setter code dest di) (case endianness (:be ``(,,setter ,,code ,,dest ,,di 2 :be)) (:le ``(,,setter ,,code ,,dest ,,di 2 :le)) (t ``(,,setter ,,code ,,dest ,,di 2 :ne))))) `(progn (define-octet-counter ,name (getter type) `(utf16-octet-counter ,getter ,type)) (define-code-point-counter ,name (getter type) `(named-lambda ,',code-point-counter-name (seq start end max) (declare (type ,type seq) (fixnum start end max)) (let* ,,(make-bom-check-form ''end ''start 'getter ''seq) (loop with count fixnum = 0 with i fixnum = start while (<= i (- end 2)) do (let* ((code ,,(make-getter-form 'getter ''seq ''i)) (next-i (+ i (if (or (< code #xd800) (>= code #xdc00)) 2 4)))) (declare (type (unsigned-byte 16) code) (fixnum next-i)) (cond ((> next-i end) (decoding-error (vector (,getter seq i) (,getter seq (1+ i))) ,',name seq i nil 'end-of-input-in-character) (return (values count i))) (t (setq i next-i count (1+ count)) (when (and (plusp max) (= count max)) (return (values count i)))))) finally (progn (assert (= i end)) (return (values count i))))))) (define-encoder ,name (getter src-type setter dest-type) `(named-lambda ,',encoder-name (src start end dest d-start) (declare (type ,src-type src) (type ,dest-type dest) (fixnum start end d-start)) (loop with di fixnum = d-start for i fixnum from start below end for code of-type code-point = (,getter src i) for high-bits fixnum = (- code #x10000) do (cond ((< high-bits 0) ,,(make-setter-form 'setter ''code ''dest ''di) (incf di 2)) (t ,,(make-setter-form 'setter ''(logior #xd800 (f-ash high-bits -10)) ''dest ''di) ,,(make-setter-form 'setter ''(logior #xdc00 (f-logand high-bits #x3ff)) ''dest ''(+ di 2)) (incf di 4))) finally (return (the fixnum (- di d-start)))))) (define-decoder ,name (getter src-type setter dest-type) `(named-lambda ,',decoder-name (src start end dest d-start) (declare (type ,src-type src) (type ,dest-type dest) (fixnum start end d-start)) (let ,,(make-bom-check-form ''end ''start 'getter ''src) (loop with i fixnum = start for di fixnum from d-start until (= i end) do (let ((u1 ,,(make-getter-form 'getter ''src ''i))) (declare (type (unsigned-byte 16) u1)) (incf i 2) (,setter (cond ((or (< u1 #xd800) (>= u1 #xe000)) ; 2 octets u1) ((< u1 #xdc00) ; 4 octets (let ((u2 ,,(make-getter-form 'getter ''src ''i))) (declare (type (unsigned-byte 16) u2)) (incf i 2) (if (and (>= u2 #xdc00) (< u2 #xe000)) (utf-16-combine-surrogate-pairs u1 u2) (decoding-error (vector (,getter src (- i 4)) (,getter src (- i 3)) (,getter src (- i 2)) (,getter src (- i 1))) ,',name src i +repl+)))) (t (decoding-error (vector (,getter src (- i 2)) (,getter src (- i 1))) ,',name src i +repl+))) dest di)) finally (return (the fixnum (- di d-start))))))) ',name)))) (define-character-encoding :utf-16 "A 16-bit, variable-length encoding in which characters with code points less than #x10000 can be encoded in a single 16-bit word and characters with larger codes can be encoded in a pair of 16-bit words. The endianness of the encoded data is indicated by the endianness of a byte-order-mark character (#\u+feff) prepended to the data; in the absence of such a character on input, the data is assumed to be in big-endian order. Output is written in native byte-order with a leading byte-order mark." :max-units-per-char 2 :code-unit-size 16 :native-endianness t ; not necessarily true when decoding :decode-literal-code-unit-limit #xd800 :encode-literal-code-unit-limit #x10000 :use-bom #+big-endian :utf-16be #+little-endian :utf-16le :bom-encoding #+big-endian #(#xfe #xff) #+little-endian #(#xff #xfe) :nul-encoding #(0 0) :default-replacement #xfffd :ambiguous #+little-endian t #+big-endian nil) (define-utf-16 :utf-16) (define-character-encoding :utf-16le "A 16-bit, variable-length encoding in which characters with code points less than #x10000 can be encoded in a single 16-bit word and characters with larger codes can be encoded in a pair of 16-bit words. The data is assumed to be in little-endian order. Output is written in little-endian byte-order without a leading byte-order mark." :aliases '(:utf-16/le) :max-units-per-char 2 :code-unit-size 16 :native-endianness #+little-endian t #+big-endian nil :decode-literal-code-unit-limit #xd800 :encode-literal-code-unit-limit #x10000 :nul-encoding #(0 0) :default-replacement #xfffd) (define-utf-16 :utf-16le :le) (define-character-encoding :utf-16be "A 16-bit, variable-length encoding in which characters with code points less than #x10000 can be encoded in a single 16-bit word and characters with larger codes can be encoded in a pair of 16-bit words. The data is assumed to be in big-endian order. Output is written in big-endian byte-order without a leading byte-order mark." :aliases '(:utf-16/be) :max-units-per-char 2 :code-unit-size 16 :native-endianness #+little-endian nil #+big-endian t :decode-literal-code-unit-limit #xd800 :encode-literal-code-unit-limit #x10000 :nul-encoding #(0 0) :default-replacement #xfffd) (define-utf-16 :utf-16be :be) (defmacro define-ucs (name bytes &optional endianness (limit #x110000)) (check-type name keyword) (check-type bytes (or (eql 2) (eql 4))) (check-type endianness (or null (eql :le) (eql :be))) (let ((swap-var (gensym "SWAP")) (code-point-counter-name (format-symbol t '#:~a-code-point-counter (string name))) (encoder-name (format-symbol t '#:~a-encoder (string name))) (decoder-name (format-symbol t '#:~a-decoder (string name)))) (labels ((make-bom-check-form (end start getter src) (if (null endianness) ``(when (not (zerop (- ,,end ,,start))) (case (,,getter ,,src 0 ,',bytes :ne) (#.+byte-order-mark-code+ (incf ,,start ,',bytes) nil) (#.+swapped-byte-order-mark-code-32+ (incf ,,start ,',bytes) t) (t #+little-endian t))) '())) (make-setter-form (setter code dest di) ``(,,setter ,,code ,,dest ,,di ,',bytes ,',(or endianness :ne))) (make-getter-form (getter src i) (if (null endianness) ``(if ,',swap-var (,,getter ,,src ,,i ,',bytes :re) (,,getter ,,src ,,i ,',bytes :ne)) ``(,,getter ,,src ,,i ,',bytes ,',endianness)))) `(progn (define-code-point-counter ,name (getter type) `(named-lambda ,',code-point-counter-name (seq start end max) (declare (type ,type seq) (fixnum start end max)) ;; check for bom ,,(make-bom-check-form ''end ''start 'getter ''seq) (multiple-value-bind (count rem) (floor (- end start) ,',bytes) (cond ((and (plusp max) (> count max)) (values max (the fixnum (+ start (* ,',bytes max))))) (t ;; check for incomplete last character (unless (zerop rem) (let ((vector (make-array ,',bytes :fill-pointer 0))) (dotimes (i rem) (vector-push (,getter seq (+ i (- end rem))) vector)) (decoding-error vector ,',name seq (the fixnum (- end rem)) nil 'end-of-input-in-character) (decf end rem))) (values count end)))))) (define-encoder ,name (getter src-type setter dest-type) `(named-lambda ,',encoder-name (src start end dest d-start) (declare (type ,src-type src) (type ,dest-type dest) (fixnum start end d-start)) (loop for i fixnum from start below end for di fixnum from d-start by ,',bytes for code of-type code-point = (,getter src i) do (if (>= code ,',limit) (encoding-error code ,',name src i +repl+) ,,(make-setter-form 'setter ''code ''dest ''di)) finally (return (the fixnum (- di d-start)))))) (define-decoder ,name (getter src-type setter dest-type) `(named-lambda ,',decoder-name (src start end dest d-start) (declare (type ,src-type src) (type ,dest-type dest) (fixnum start end d-start)) (let ((,',swap-var ,,(make-bom-check-form ''end ''start 'getter ''src))) (declare (ignorable ,',swap-var)) (loop for i fixnum from start below end by ,',bytes for di from d-start do (,setter (let ((unit ,,(make-getter-form 'getter ''src ''i))) (if (>= unit ,',limit) (decoding-error (vector (,getter src i) (,getter src (+ i 1)) ,@,(if (= bytes 4) ``((,getter src (+ i 2)) (,getter src (+ i 3))))) ,',name src i +repl+ 'character-out-of-range) unit)) dest di) finally (return (the fixnum (- di d-start))))))) ',name)))) ;;;; UTF-32 (define-character-encoding :utf-32 "A 32-bit, fixed-length encoding in which all Unicode characters can be encoded in a single 32-bit word. The endianness of the encoded data is indicated by the endianness of a byte-order-mark character (#\u+feff) prepended to the data; in the absence of such a character on input, input data is assumed to be in big-endian order. Output is written in native byte order with a leading byte-order mark." :aliases '(:ucs-4) :max-units-per-char 1 :code-unit-size 32 :native-endianness t ; not necessarily true when decoding :literal-char-code-limit #x110000 :use-bom #+little-endian :utf-32le #+big-endian :utf-32be :bom-encoding #+big-endian #(#x00 #x00 #xfe #xff) #+little-endian #(#xff #xfe #x00 #x00) :nul-encoding #(0 0 0 0) :ambiguous #+little-endian t #+big-endian nil) (define-ucs :utf-32 4) (define-character-encoding :utf-32le "A 32-bit, fixed-length encoding in which all Unicode characters can be encoded in a single 32-bit word. Input data is assumed to be in little-endian order. Output is also written in little-endian byte order without a leading byte-order mark." :max-units-per-char 1 :code-unit-size 32 :aliases '(:utf-32/le :ucs-4le :ucs-4/le) :native-endianness #+little-endian t #+big-endian nil :literal-char-code-limit #x110000 :nul-encoding #(0 0 0 0)) (define-ucs :utf-32le 4 :le) (define-character-encoding :utf-32be "A 32-bit, fixed-length encoding in which all Unicode characters can be encoded in a single 32-bit word. Input data is assumed to be in big-endian order. Output is also written in big-endian byte order without a leading byte-order mark." :max-units-per-char 1 :code-unit-size 32 :aliases '(:utf-32/be :ucs-4be :ucs-4/be) :native-endianness #+little-endian nil #+big-endian t :literal-char-code-limit #x110000 :nul-encoding #(0 0 0 0)) (define-ucs :utf-32be 4 :be) ;; UCS-2 (define-character-encoding :ucs-2 "A 16-bit, fixed-length encoding in which all Unicode characters can be encoded in a single 16-bit word. The endianness of the encoded data is indicated by the endianness of a byte-order-mark character (#\u+feff) prepended to the data; in the absence of such a character on input, input data is assumed to be in big-endian order. Output is written in native byte order with a leading byte-order mark." :aliases '(:ucs-2) :max-units-per-char 1 :code-unit-size 16 :native-endianness t ; not necessarily true when decoding :literal-char-code-limit #x10000 :use-bom #+little-endian :ucs-2le #+big-endian :ucs-2be :bom-encoding #+big-endian #(#xfe #xff) #+little-endian #(#xff #xfe) :nul-encoding #(0 0) :ambiguous #+little-endian t #+big-endian nil) (define-ucs :ucs-2 2 nil #x10000) (define-character-encoding :ucs-2le "A 16-bit, fixed-length encoding in which all Unicode characters can be encoded in a single 16-bit word. Input data is assumed to be in little-endian order. Output is also written in little-endian byte order without a leading byte-order mark." :max-units-per-char 1 :code-unit-size 16 :aliases '(:ucs-2/le) :native-endianness #+little-endian t #+big-endian nil :literal-char-code-limit #x10000 :nul-encoding #(0 0)) (define-ucs :ucs-2le 2 :le #x10000) (define-character-encoding :ucs-2be "A 16-bit, fixed-length encoding in which all Unicode characters can be encoded in a single 16-bit word. Input data is assumed to be in big-endian order. Output is also written in big-endian byte order without a leading byte-order mark." :max-units-per-char 1 :code-unit-size 16 :aliases '(:ucs-2/be) :native-endianness #+little-endian nil #+big-endian t :literal-char-code-limit #x10000 :nul-encoding #(0 0)) (define-ucs :ucs-2be 2 :be #x10000)

Common Lisp

.lisp

cac-t-u-s/om-sharp

GPL-3.0

9/19/2024, 11:25:22 AM (Europe/Amsterdam)

61b1c8ccf68c4c61572430280b434d097d98469116d3285c21c23badd5ca3e9f

packages.lisp

cac-t-u-s_om-sharp/src/api/foreign-interface/ffi/babel/src/packages.lisp

;;;; -*- Mode: lisp; indent-tabs-mode: nil -*- ;;; ;;; package.lisp --- Package definition for Babel ;;; ;;; Copyright (C) 2007, Luis Oliveira <[email protected]> ;;; ;;; Permission is hereby granted, free of charge, to any person ;;; obtaining a copy of this software and associated documentation ;;; files (the "Software"), to deal in the Software without ;;; restriction, including without limitation the rights to use, copy, ;;; modify, merge, publish, distribute, sublicense, and/or sell copies ;;; of the Software, and to permit persons to whom the Software is ;;; furnished to do so, subject to the following conditions: ;;; ;;; The above copyright notice and this permission notice shall be ;;; included in all copies or substantial portions of the Software. ;;; ;;; THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, ;;; EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF ;;; MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND ;;; NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT ;;; HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, ;;; WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, ;;; OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER ;;; DEALINGS IN THE SOFTWARE. (in-package #:cl-user) (defpackage #:babel-encodings (:use #:common-lisp #:alexandria) (:export ;; character encoding objects #:list-character-encodings #:character-encoding #:*default-character-encoding* #:get-character-encoding #:enc-name #:enc-aliases #:enc-code-unit-size #:enc-max-units-per-char #:enc-native-endianness #:enc-decode-literal-code-unit-limit #:enc-encode-literal-code-unit-limit #:enc-use-bom #:enc-bom-encoding #:enc-nul-encoding #:enc-default-replacement #:ambiguous-encoding-p ;; concrete mappings #:instantiate-concrete-mappings #:encoder #:decoder #:octet-counter #:code-point-counter #:lookup-mapping #:with-simple-vector #:with-checked-simple-vector #:*suppress-character-coding-errors* ;; errors #:character-coding-error #:character-coding-error-encoding ; accessor #:character-coding-error-buffer ; accessor #:character-coding-error-position ; accessor #:character-decoding-error #:character-decoding-error-octets ; accessor #:character-encoding-error #:character-encoding-error-code ; accessor #:end-of-input-in-character #:character-out-of-range #:invalid-utf8-starter-byte #:invalid-utf8-continuation-byte #:overlong-utf8-sequence)) (defpackage #:babel (:use #:common-lisp #:babel-encodings #:alexandria) (:import-from #:babel-encodings) (:export ;; types #:unicode-char #:unicode-char-code-limit #:unicode-string #:simple-unicode-string ;; fixed sharp-backslash reader #:enable-sharp-backslash-syntax #:set-sharp-backslash-syntax-in-readtable ;; external formats #:external-format #:make-external-format #:ensure-external-format #:external-format-encoding #:external-format-eol-style #:external-format-equal #:*default-eol-style* ;; general user API #:*default-character-encoding* #:list-character-encodings #:string-to-octets #:octets-to-string #:concatenate-strings-to-octets #:string-size-in-octets #:vector-size-in-chars ;; errors #:character-coding-error #:character-coding-error-encoding ; accessor #:character-coding-error-buffer ; accessor #:character-coding-error-position ; accessor #:character-decoding-error #:character-decoding-error-octets ; accessor #:character-encoding-error #:character-encoding-error-code ; accessor #:end-of-input-in-character #:character-out-of-range #:invalid-utf8-starter-byte #:invalid-utf8-continuation-byte #:overlong-utf8-sequence))

Common Lisp

.lisp

cac-t-u-s/om-sharp

GPL-3.0

9/19/2024, 11:25:22 AM (Europe/Amsterdam)

90191d8b2ce524fa1b1edee0030fc8f733d118d2b15694ed231a9ef50f937ca6

jpn-table.lisp

cac-t-u-s_om-sharp/src/api/foreign-interface/ffi/babel/src/jpn-table.lisp

;;;; -*- Mode: lisp; indent-tabs-mode: nil -*- ;;; ;;; jpn-table.lisp --- Unicode tables for Japanese encodings. ;;; (in-package #:babel-encodings) (defvar *cp932-only* '((#xFC4B #x9ED1) (#xFC4A #x9E19) (#xFC49 #xFA2D) (#xFC48 #x9D6B) (#xFC47 #x9D70) (#xFC46 #x9C00) (#xFC45 #x9BBB) (#xFC44 #x9BB1) (#xFC43 #x9B8F) (#xFC42 #x9B72) (#xFC41 #x9B75) (#xFC40 #x9ADC) (#xFBFC #x9AD9) (#xFBFB #x9A4E) (#xFBFA #x999E) (#xFBF9 #xFA2C) (#xFBF8 #x9927) (#xFBF7 #xFA2B) (#xFBF6 #xFA2A) (#xFBF5 #x9865) (#xFBF4 #x9857) (#xFBF3 #x9755) (#xFBF2 #x9751) (#xFBF1 #x974F) (#xFBF0 #x974D) (#xFBEF #x9743) (#xFBEE #x973B) (#xFBED #x9733) (#xFBEC #x96AF) (#xFBEB #x969D) (#xFBEA #xFA29) (#xFBE9 #xF9DC) (#xFBE8 #x9592) (#xFBE7 #x9448) (#xFBE6 #x9445) (#xFBE5 #x9431) (#xFBE4 #x93F8) (#xFBE3 #x93DE) (#xFBE2 #x93C6) (#xFBE1 #x93A4) (#xFBE0 #x9357) (#xFBDF #x9370) (#xFBDE #x9302) (#xFBDD #x931D) (#xFBDC #x92FF) (#xFBDB #x931E) (#xFBDA #xFA28) (#xFBD9 #x92FB) (#xFBD8 #x9321) (#xFBD7 #x9325) (#xFBD6 #x92D3) (#xFBD5 #x92E0) (#xFBD4 #x92D5) (#xFBD3 #xFA27) (#xFBD2 #x92D0) (#xFBD1 #x92D9) (#xFBD0 #x92D7) (#xFBCF #x92E7) (#xFBCE #x9278) (#xFBCD #x9277) (#xFBCC #x92A7) (#xFBCB #x9267) (#xFBCA #x9239) (#xFBC9 #x9251) (#xFBC8 #x9259) (#xFBC7 #x924E) (#xFBC6 #x923C) (#xFBC5 #x9240) (#xFBC4 #x923A) (#xFBC3 #x920A) (#xFBC2 #x9210) (#xFBC1 #x9206) (#xFBC0 #x91E5) (#xFBBF #x91E4) (#xFBBE #x91EE) (#xFBBD #x91ED) (#xFBBC #x91DE) (#xFBBB #x91D7) (#xFBBA #x91DA) (#xFBB9 #x9127) (#xFBB8 #x9115) (#xFBB7 #xFA26) (#xFBB6 #x90DE) (#xFBB5 #x9067) (#xFBB4 #xFA25) (#xFBB3 #xFA24) (#xFBB2 #x8ECF) (#xFBB1 #xFA23) (#xFBB0 #x8D76) (#xFBAF #x8D12) (#xFBAE #x8CF4) (#xFBAD #x8CF0) (#xFBAC #x8B7F) (#xFBAB #x8B53) (#xFBAA #x8AF6) (#xFBA9 #xFA22) (#xFBA8 #x8ADF) (#xFBA7 #x8ABE) (#xFBA6 #x8AA7) (#xFBA5 #x8A79) (#xFBA4 #x8A37) (#xFBA3 #x8A12) (#xFBA2 #x88F5) (#xFBA1 #x8807) (#xFBA0 #xFA21) (#xFB9F #xFA20) (#xFB9E #x85B0) (#xFB9D #xFA1F) (#xFB9C #x856B) (#xFB9B #x8559) (#xFB9A #x8553) (#xFB99 #x84B4) (#xFB98 #x8448) (#xFB97 #x83F6) (#xFB96 #x83C7) (#xFB95 #x837F) (#xFB94 #x8362) (#xFB93 #x8301) (#xFB92 #xFA1E) (#xFB91 #x7FA1) (#xFB90 #x7F47) (#xFB8F #x7E52) (#xFB8E #x7DD6) (#xFB8D #x7DA0) (#xFB8C #x7DB7) (#xFB8B #x7D5C) (#xFB8A #x7D48) (#xFB89 #xFA1D) (#xFB88 #x7B9E) (#xFB87 #x7AEB) (#xFB86 #xFA1C) (#xFB85 #x7AE7) (#xFB84 #x7AD1) (#xFB83 #x799B) (#xFB82 #xFA1B) (#xFB81 #x7994) (#xFB80 #xFA1A) (#xFB7E #xFA19) (#xFB7D #xFA18) (#xFB7C #x7930) (#xFB7B #x787A) (#xFB7A #x7864) (#xFB79 #x784E) (#xFB78 #x7821) (#xFB77 #x52AF) (#xFB76 #x7746) (#xFB75 #xFA17) (#xFB74 #x76A6) (#xFB73 #x769B) (#xFB72 #x769E) (#xFB71 #x769C) (#xFB70 #x7682) (#xFB6F #x756F) (#xFB6E #x7501) (#xFB6D #x749F) (#xFB6C #x7489) (#xFB6B #x7462) (#xFB6A #x742E) (#xFB69 #x7429) (#xFB68 #x742A) (#xFB67 #x7426) (#xFB66 #x73F5) (#xFB65 #x7407) (#xFB64 #x73D2) (#xFB63 #x73E3) (#xFB62 #x73D6) (#xFB61 #x73C9) (#xFB60 #x73BD) (#xFB5F #x7377) (#xFB5E #xFA16) (#xFB5D #x7324) (#xFB5C #x72BE) (#xFB5B #x72B1) (#xFB5A #x71FE) (#xFB59 #x71C1) (#xFB58 #xFA15) (#xFB57 #x7147) (#xFB56 #x7146) (#xFB55 #x715C) (#xFB54 #x7104) (#xFB53 #x710F) (#xFB52 #x70AB) (#xFB51 #x7085) (#xFB50 #x7028) (#xFB4F #x7007) (#xFB4E #x7005) (#xFB4D #x6FF5) (#xFB4C #x6FB5) (#xFB4B #x6F88) (#xFB4A #x6EBF) (#xFB49 #x6E3C) (#xFB48 #x6E27) (#xFB47 #x6E5C) (#xFB46 #x6E39) (#xFB45 #x6DFC) (#xFB44 #x6DF2) (#xFB43 #x6DF8) (#xFB42 #x6DCF) (#xFB41 #x6DAC) (#xFB40 #x6D96) (#xFAFC #x6D6F) (#xFAFB #x6D87) (#xFAFA #x6D04) (#xFAF9 #x6CDA) (#xFAF8 #x6C6F) (#xFAF7 #x6C86) (#xFAF6 #x6C5C) (#xFAF5 #x6C3F) (#xFAF4 #x6BD6) (#xFAF3 #x6AE4) (#xFAF2 #x6AE2) (#xFAF1 #x6A7E) (#xFAF0 #x6A73) (#xFAEF #x6A46) (#xFAEE #x6A6B) (#xFAED #x6A30) (#xFAEC #x69E2) (#xFAEB #x6998) (#xFAEA #xFA14) (#xFAE9 #x6968) (#xFAE8 #xFA13) (#xFAE7 #x68CF) (#xFAE6 #x6844) (#xFAE5 #x6801) (#xFAE4 #x67C0) (#xFAE3 #x6852) (#xFAE2 #x67BB) (#xFAE1 #x6766) (#xFAE0 #xF929) (#xFADF #x670E) (#xFADE #x66FA) (#xFADD #x66BF) (#xFADC #x66B2) (#xFADB #x66A0) (#xFADA #x6699) (#xFAD9 #x6673) (#xFAD8 #xFA12) (#xFAD7 #x6659) (#xFAD6 #x6657) (#xFAD5 #x6665) (#xFAD4 #x6624) (#xFAD3 #x661E) (#xFAD2 #x662E) (#xFAD1 #x6609) (#xFAD0 #x663B) (#xFACF #x6615) (#xFACE #x6600) (#xFACD #x654E) (#xFACC #x64CE) (#xFACB #x649D) (#xFACA #x6460) (#xFAC9 #x63F5) (#xFAC8 #x62A6) (#xFAC7 #x6213) (#xFAC6 #x6198) (#xFAC5 #x6130) (#xFAC4 #x6137) (#xFAC3 #x6111) (#xFAC2 #x60F2) (#xFAC1 #x6120) (#xFAC0 #x60D5) (#xFABF #x60DE) (#xFABE #x608A) (#xFABD #x6085) (#xFABC #x605D) (#xFABB #x5FDE) (#xFABA #x5FB7) (#xFAB9 #x5F67) (#xFAB8 #x5F34) (#xFAB7 #x5F21) (#xFAB6 #x5DD0) (#xFAB5 #x5DB9) (#xFAB4 #x5DB8) (#xFAB3 #x5D6D) (#xFAB2 #x5D42) (#xFAB1 #xFA11) (#xFAB0 #x5D53) (#xFAAF #x5D27) (#xFAAE #x5CF5) (#xFAAD #x5CBA) (#xFAAC #x5CA6) (#xFAAB #x5C1E) (#xFAAA #x5BEC) (#xFAA9 #x5BD8) (#xFAA8 #x752F) (#xFAA7 #x5BC0) (#xFAA6 #x5B56) (#xFAA5 #x59BA) (#xFAA4 #x59A4) (#xFAA3 #x5963) (#xFAA2 #x595D) (#xFAA1 #x595B) (#xFAA0 #x5953) (#xFA9F #x590B) (#xFA9E #x58B2) (#xFA9D #x589E) (#xFA9C #xFA10) (#xFA9B #xFA0F) (#xFA9A #x57C7) (#xFA99 #x57C8) (#xFA98 #x57AC) (#xFA97 #x5765) (#xFA96 #x5759) (#xFA95 #x5586) (#xFA94 #x54FF) (#xFA93 #x54A9) (#xFA92 #x548A) (#xFA91 #x549C) (#xFA90 #xFA0E) (#xFA8F #x53DD) (#xFA8E #x53B2) (#xFA8D #x5393) (#xFA8C #x5372) (#xFA8B #x5324) (#xFA8A #x5307) (#xFA89 #x5300) (#xFA88 #x52DB) (#xFA87 #x52C0) (#xFA86 #x52A6) (#xFA85 #x529C) (#xFA84 #x5215) (#xFA83 #x51EC) (#xFA82 #x51BE) (#xFA81 #x519D) (#xFA80 #x5164) (#xFA7E #x514A) (#xFA7D #x50D8) (#xFA7C #x50F4) (#xFA7B #x5094) (#xFA7A #x5042) (#xFA79 #x5070) (#xFA78 #x5046) (#xFA77 #x501E) (#xFA76 #x4FFF) (#xFA75 #x5022) (#xFA74 #x5040) (#xFA73 #x4FCD) (#xFA72 #x4F94) (#xFA71 #x4F9A) (#xFA70 #x4F8A) (#xFA6F #x4F92) (#xFA6E #x4F56) (#xFA6D #x4F39) (#xFA6C #x4F03) (#xFA6B #x4F00) (#xFA6A #x4EFC) (#xFA69 #x4EE1) (#xFA68 #x4E28) (#xFA67 #x5F45) (#xFA66 #x66FB) (#xFA65 #x92F9) (#xFA64 #x68C8) (#xFA63 #x6631) (#xFA62 #x70BB) (#xFA61 #x4FC9) (#xFA60 #x84DC) (#xFA5F #x9288) (#xFA5E #x9348) (#xFA5D #x891C) (#xFA5C #x7E8A) (#xFA5B #x2235) (#xFA5A #x2121) (#xFA59 #x2116) (#xFA58 #x3231) (#xFA57 #xFF02) (#xFA56 #xFF07) (#xFA55 #xFFE4) (#xFA54 #xFFE2) (#xFA53 #x2169) (#xFA52 #x2168) (#xFA51 #x2167) (#xFA50 #x2166) (#xFA4F #x2165) (#xFA4E #x2164) (#xFA4D #x2163) (#xFA4C #x2162) (#xFA4B #x2161) (#xFA4A #x2160) (#xFA49 #x2179) (#xFA48 #x2178) (#xFA47 #x2177) (#xFA46 #x2176) (#xFA45 #x2175) (#xFA44 #x2174) (#xFA43 #x2173) (#xFA42 #x2172) (#xFA41 #x2171) (#xFA40 #x2170) (#xF9FC #xE757) (#xF9FB #xE756) (#xF9FA #xE755) (#xF9F9 #xE754) (#xF9F8 #xE753) (#xF9F7 #xE752) (#xF9F6 #xE751) (#xF9F5 #xE750) (#xF9F4 #xE74F) (#xF9F3 #xE74E) (#xF9F2 #xE74D) (#xF9F1 #xE74C) (#xF9F0 #xE74B) (#xF9EF #xE74A) (#xF9EE #xE749) (#xF9ED #xE748) (#xF9EC #xE747) (#xF9EB #xE746) (#xF9EA #xE745) (#xF9E9 #xE744) (#xF9E8 #xE743) (#xF9E7 #xE742) (#xF9E6 #xE741) (#xF9E5 #xE740) (#xF9E4 #xE73F) (#xF9E3 #xE73E) (#xF9E2 #xE73D) (#xF9E1 #xE73C) (#xF9E0 #xE73B) (#xF9DF #xE73A) (#xF9DE #xE739) (#xF9DD #xE738) (#xF9DC #xE737) (#xF9DB #xE736) (#xF9DA #xE735) (#xF9D9 #xE734) (#xF9D8 #xE733) (#xF9D7 #xE732) (#xF9D6 #xE731) (#xF9D5 #xE730) (#xF9D4 #xE72F) (#xF9D3 #xE72E) (#xF9D2 #xE72D) (#xF9D1 #xE72C) (#xF9D0 #xE72B) (#xF9CF #xE72A) (#xF9CE #xE729) (#xF9CD #xE728) (#xF9CC #xE727) (#xF9CB #xE726) (#xF9CA #xE725) (#xF9C9 #xE724) (#xF9C8 #xE723) (#xF9C7 #xE722) (#xF9C6 #xE721) (#xF9C5 #xE720) (#xF9C4 #xE71F) (#xF9C3 #xE71E) (#xF9C2 #xE71D) (#xF9C1 #xE71C) (#xF9C0 #xE71B) (#xF9BF #xE71A) (#xF9BE #xE719) (#xF9BD #xE718) (#xF9BC #xE717) (#xF9BB #xE716) (#xF9BA #xE715) (#xF9B9 #xE714) (#xF9B8 #xE713) (#xF9B7 #xE712) (#xF9B6 #xE711) (#xF9B5 #xE710) (#xF9B4 #xE70F) (#xF9B3 #xE70E) (#xF9B2 #xE70D) (#xF9B1 #xE70C) (#xF9B0 #xE70B) (#xF9AF #xE70A) (#xF9AE #xE709) (#xF9AD #xE708) (#xF9AC #xE707) (#xF9AB #xE706) (#xF9AA #xE705) (#xF9A9 #xE704) (#xF9A8 #xE703) (#xF9A7 #xE702) (#xF9A6 #xE701) (#xF9A5 #xE700) (#xF9A4 #xE6FF) (#xF9A3 #xE6FE) (#xF9A2 #xE6FD) (#xF9A1 #xE6FC) (#xF9A0 #xE6FB) (#xF99F #xE6FA) (#xF99E #xE6F9) (#xF99D #xE6F8) (#xF99C #xE6F7) (#xF99B #xE6F6) (#xF99A #xE6F5) (#xF999 #xE6F4) (#xF998 #xE6F3) (#xF997 #xE6F2) (#xF996 #xE6F1) (#xF995 #xE6F0) (#xF994 #xE6EF) (#xF993 #xE6EE) (#xF992 #xE6ED) (#xF991 #xE6EC) (#xF990 #xE6EB) (#xF98F #xE6EA) (#xF98E #xE6E9) (#xF98D #xE6E8) (#xF98C #xE6E7) (#xF98B #xE6E6) (#xF98A #xE6E5) (#xF989 #xE6E4) (#xF988 #xE6E3) (#xF987 #xE6E2) (#xF986 #xE6E1) (#xF985 #xE6E0) (#xF984 #xE6DF) (#xF983 #xE6DE) (#xF982 #xE6DD) (#xF981 #xE6DC) (#xF980 #xE6DB) (#xF97E #xE6DA) (#xF97D #xE6D9) (#xF97C #xE6D8) (#xF97B #xE6D7) (#xF97A #xE6D6) (#xF979 #xE6D5) (#xF978 #xE6D4) (#xF977 #xE6D3) (#xF976 #xE6D2) (#xF975 #xE6D1) (#xF974 #xE6D0) (#xF973 #xE6CF) (#xF972 #xE6CE) (#xF971 #xE6CD) (#xF970 #xE6CC) (#xF96F #xE6CB) (#xF96E #xE6CA) (#xF96D #xE6C9) (#xF96C #xE6C8) (#xF96B #xE6C7) (#xF96A #xE6C6) (#xF969 #xE6C5) (#xF968 #xE6C4) (#xF967 #xE6C3) (#xF966 #xE6C2) (#xF965 #xE6C1) (#xF964 #xE6C0) (#xF963 #xE6BF) (#xF962 #xE6BE) (#xF961 #xE6BD) (#xF960 #xE6BC) (#xF95F #xE6BB) (#xF95E #xE6BA) (#xF95D #xE6B9) (#xF95C #xE6B8) (#xF95B #xE6B7) (#xF95A #xE6B6) (#xF959 #xE6B5) (#xF958 #xE6B4) (#xF957 #xE6B3) (#xF956 #xE6B2) (#xF955 #xE6B1) (#xF954 #xE6B0) (#xF953 #xE6AF) (#xF952 #xE6AE) (#xF951 #xE6AD) (#xF950 #xE6AC) (#xF94F #xE6AB) (#xF94E #xE6AA) (#xF94D #xE6A9) (#xF94C #xE6A8) (#xF94B #xE6A7) (#xF94A #xE6A6) (#xF949 #xE6A5) (#xF948 #xE6A4) (#xF947 #xE6A3) (#xF946 #xE6A2) (#xF945 #xE6A1) (#xF944 #xE6A0) (#xF943 #xE69F) (#xF942 #xE69E) (#xF941 #xE69D) (#xF940 #xE69C) (#xF8FC #xE69B) (#xF8FB #xE69A) (#xF8FA #xE699) (#xF8F9 #xE698) (#xF8F8 #xE697) (#xF8F7 #xE696) (#xF8F6 #xE695) (#xF8F5 #xE694) (#xF8F4 #xE693) (#xF8F3 #xE692) (#xF8F2 #xE691) (#xF8F1 #xE690) (#xF8F0 #xE68F) (#xF8EF #xE68E) (#xF8EE #xE68D) (#xF8ED #xE68C) (#xF8EC #xE68B) (#xF8EB #xE68A) (#xF8EA #xE689) (#xF8E9 #xE688) (#xF8E8 #xE687) (#xF8E7 #xE686) (#xF8E6 #xE685) (#xF8E5 #xE684) (#xF8E4 #xE683) (#xF8E3 #xE682) (#xF8E2 #xE681) (#xF8E1 #xE680) (#xF8E0 #xE67F) (#xF8DF #xE67E) (#xF8DE #xE67D) (#xF8DD #xE67C) (#xF8DC #xE67B) (#xF8DB #xE67A) (#xF8DA #xE679) (#xF8D9 #xE678) (#xF8D8 #xE677) (#xF8D7 #xE676) (#xF8D6 #xE675) (#xF8D5 #xE674) (#xF8D4 #xE673) (#xF8D3 #xE672) (#xF8D2 #xE671) (#xF8D1 #xE670) (#xF8D0 #xE66F) (#xF8CF #xE66E) (#xF8CE #xE66D) (#xF8CD #xE66C) (#xF8CC #xE66B) (#xF8CB #xE66A) (#xF8CA #xE669) (#xF8C9 #xE668) (#xF8C8 #xE667) (#xF8C7 #xE666) (#xF8C6 #xE665) (#xF8C5 #xE664) (#xF8C4 #xE663) (#xF8C3 #xE662) (#xF8C2 #xE661) (#xF8C1 #xE660) (#xF8C0 #xE65F) (#xF8BF #xE65E) (#xF8BE #xE65D) (#xF8BD #xE65C) (#xF8BC #xE65B) (#xF8BB #xE65A) (#xF8BA #xE659) (#xF8B9 #xE658) (#xF8B8 #xE657) (#xF8B7 #xE656) (#xF8B6 #xE655) (#xF8B5 #xE654) (#xF8B4 #xE653) (#xF8B3 #xE652) (#xF8B2 #xE651) (#xF8B1 #xE650) (#xF8B0 #xE64F) (#xF8AF #xE64E) (#xF8AE #xE64D) (#xF8AD #xE64C) (#xF8AC #xE64B) (#xF8AB #xE64A) (#xF8AA #xE649) (#xF8A9 #xE648) (#xF8A8 #xE647) (#xF8A7 #xE646) (#xF8A6 #xE645) (#xF8A5 #xE644) (#xF8A4 #xE643) (#xF8A3 #xE642) (#xF8A2 #xE641) (#xF8A1 #xE640) (#xF8A0 #xE63F) (#xF89F #xE63E) (#xF89E #xE63D) (#xF89D #xE63C) (#xF89C #xE63B) (#xF89B #xE63A) (#xF89A #xE639) (#xF899 #xE638) (#xF898 #xE637) (#xF897 #xE636) (#xF896 #xE635) (#xF895 #xE634) (#xF894 #xE633) (#xF893 #xE632) (#xF892 #xE631) (#xF891 #xE630) (#xF890 #xE62F) (#xF88F #xE62E) (#xF88E #xE62D) (#xF88D #xE62C) (#xF88C #xE62B) (#xF88B #xE62A) (#xF88A #xE629) (#xF889 #xE628) (#xF888 #xE627) (#xF887 #xE626) (#xF886 #xE625) (#xF885 #xE624) (#xF884 #xE623) (#xF883 #xE622) (#xF882 #xE621) (#xF881 #xE620) (#xF880 #xE61F) (#xF87E #xE61E) (#xF87D #xE61D) (#xF87C #xE61C) (#xF87B #xE61B) (#xF87A #xE61A) (#xF879 #xE619) (#xF878 #xE618) (#xF877 #xE617) (#xF876 #xE616) (#xF875 #xE615) (#xF874 #xE614) (#xF873 #xE613) (#xF872 #xE612) (#xF871 #xE611) (#xF870 #xE610) (#xF86F #xE60F) (#xF86E #xE60E) (#xF86D #xE60D) (#xF86C #xE60C) (#xF86B #xE60B) (#xF86A #xE60A) (#xF869 #xE609) (#xF868 #xE608) (#xF867 #xE607) (#xF866 #xE606) (#xF865 #xE605) (#xF864 #xE604) (#xF863 #xE603) (#xF862 #xE602) (#xF861 #xE601) (#xF860 #xE600) (#xF85F #xE5FF) (#xF85E #xE5FE) (#xF85D #xE5FD) (#xF85C #xE5FC) (#xF85B #xE5FB) (#xF85A #xE5FA) (#xF859 #xE5F9) (#xF858 #xE5F8) (#xF857 #xE5F7) (#xF856 #xE5F6) (#xF855 #xE5F5) (#xF854 #xE5F4) (#xF853 #xE5F3) (#xF852 #xE5F2) (#xF851 #xE5F1) (#xF850 #xE5F0) (#xF84F #xE5EF) (#xF84E #xE5EE) (#xF84D #xE5ED) (#xF84C #xE5EC) (#xF84B #xE5EB) (#xF84A #xE5EA) (#xF849 #xE5E9) (#xF848 #xE5E8) (#xF847 #xE5E7) (#xF846 #xE5E6) (#xF845 #xE5E5) (#xF844 #xE5E4) (#xF843 #xE5E3) (#xF842 #xE5E2) (#xF841 #xE5E1) (#xF840 #xE5E0) (#xF7FC #xE5DF) (#xF7FB #xE5DE) (#xF7FA #xE5DD) (#xF7F9 #xE5DC) (#xF7F8 #xE5DB) (#xF7F7 #xE5DA) (#xF7F6 #xE5D9) (#xF7F5 #xE5D8) (#xF7F4 #xE5D7) (#xF7F3 #xE5D6) (#xF7F2 #xE5D5) (#xF7F1 #xE5D4) (#xF7F0 #xE5D3) (#xF7EF #xE5D2) (#xF7EE #xE5D1) (#xF7ED #xE5D0) (#xF7EC #xE5CF) (#xF7EB #xE5CE) (#xF7EA #xE5CD) (#xF7E9 #xE5CC) (#xF7E8 #xE5CB) (#xF7E7 #xE5CA) (#xF7E6 #xE5C9) (#xF7E5 #xE5C8) (#xF7E4 #xE5C7) (#xF7E3 #xE5C6) (#xF7E2 #xE5C5) (#xF7E1 #xE5C4) (#xF7E0 #xE5C3) (#xF7DF #xE5C2) (#xF7DE #xE5C1) (#xF7DD #xE5C0) (#xF7DC #xE5BF) (#xF7DB #xE5BE) (#xF7DA #xE5BD) (#xF7D9 #xE5BC) (#xF7D8 #xE5BB) (#xF7D7 #xE5BA) (#xF7D6 #xE5B9) (#xF7D5 #xE5B8) (#xF7D4 #xE5B7) (#xF7D3 #xE5B6) (#xF7D2 #xE5B5) (#xF7D1 #xE5B4) (#xF7D0 #xE5B3) (#xF7CF #xE5B2) (#xF7CE #xE5B1) (#xF7CD #xE5B0) (#xF7CC #xE5AF) (#xF7CB #xE5AE) (#xF7CA #xE5AD) (#xF7C9 #xE5AC) (#xF7C8 #xE5AB) (#xF7C7 #xE5AA) (#xF7C6 #xE5A9) (#xF7C5 #xE5A8) (#xF7C4 #xE5A7) (#xF7C3 #xE5A6) (#xF7C2 #xE5A5) (#xF7C1 #xE5A4) (#xF7C0 #xE5A3) (#xF7BF #xE5A2) (#xF7BE #xE5A1) (#xF7BD #xE5A0) (#xF7BC #xE59F) (#xF7BB #xE59E) (#xF7BA #xE59D) (#xF7B9 #xE59C) (#xF7B8 #xE59B) (#xF7B7 #xE59A) (#xF7B6 #xE599) (#xF7B5 #xE598) (#xF7B4 #xE597) (#xF7B3 #xE596) (#xF7B2 #xE595) (#xF7B1 #xE594) (#xF7B0 #xE593) (#xF7AF #xE592) (#xF7AE #xE591) (#xF7AD #xE590) (#xF7AC #xE58F) (#xF7AB #xE58E) (#xF7AA #xE58D) (#xF7A9 #xE58C) (#xF7A8 #xE58B) (#xF7A7 #xE58A) (#xF7A6 #xE589) (#xF7A5 #xE588) (#xF7A4 #xE587) (#xF7A3 #xE586) (#xF7A2 #xE585) (#xF7A1 #xE584) (#xF7A0 #xE583) (#xF79F #xE582) (#xF79E #xE581) (#xF79D #xE580) (#xF79C #xE57F) (#xF79B #xE57E) (#xF79A #xE57D) (#xF799 #xE57C) (#xF798 #xE57B) (#xF797 #xE57A) (#xF796 #xE579) (#xF795 #xE578) (#xF794 #xE577) (#xF793 #xE576) (#xF792 #xE575) (#xF791 #xE574) (#xF790 #xE573) (#xF78F #xE572) (#xF78E #xE571) (#xF78D #xE570) (#xF78C #xE56F) (#xF78B #xE56E) (#xF78A #xE56D) (#xF789 #xE56C) (#xF788 #xE56B) (#xF787 #xE56A) (#xF786 #xE569) (#xF785 #xE568) (#xF784 #xE567) (#xF783 #xE566) (#xF782 #xE565) (#xF781 #xE564) (#xF780 #xE563) (#xF77E #xE562) (#xF77D #xE561) (#xF77C #xE560) (#xF77B #xE55F) (#xF77A #xE55E) (#xF779 #xE55D) (#xF778 #xE55C) (#xF777 #xE55B) (#xF776 #xE55A) (#xF775 #xE559) (#xF774 #xE558) (#xF773 #xE557) (#xF772 #xE556) (#xF771 #xE555) (#xF770 #xE554) (#xF76F #xE553) (#xF76E #xE552) (#xF76D #xE551) (#xF76C #xE550) (#xF76B #xE54F) (#xF76A #xE54E) (#xF769 #xE54D) (#xF768 #xE54C) (#xF767 #xE54B) (#xF766 #xE54A) (#xF765 #xE549) (#xF764 #xE548) (#xF763 #xE547) (#xF762 #xE546) (#xF761 #xE545) (#xF760 #xE544) (#xF75F #xE543) (#xF75E #xE542) (#xF75D #xE541) (#xF75C #xE540) (#xF75B #xE53F) (#xF75A #xE53E) (#xF759 #xE53D) (#xF758 #xE53C) (#xF757 #xE53B) (#xF756 #xE53A) (#xF755 #xE539) (#xF754 #xE538) (#xF753 #xE537) (#xF752 #xE536) (#xF751 #xE535) (#xF750 #xE534) (#xF74F #xE533) (#xF74E #xE532) (#xF74D #xE531) (#xF74C #xE530) (#xF74B #xE52F) (#xF74A #xE52E) (#xF749 #xE52D) (#xF748 #xE52C) (#xF747 #xE52B) (#xF746 #xE52A) (#xF745 #xE529) (#xF744 #xE528) (#xF743 #xE527) (#xF742 #xE526) (#xF741 #xE525) (#xF740 #xE524) (#xF6FC #xE523) (#xF6FB #xE522) (#xF6FA #xE521) (#xF6F9 #xE520) (#xF6F8 #xE51F) (#xF6F7 #xE51E) (#xF6F6 #xE51D) (#xF6F5 #xE51C) (#xF6F4 #xE51B) (#xF6F3 #xE51A) (#xF6F2 #xE519) (#xF6F1 #xE518) (#xF6F0 #xE517) (#xF6EF #xE516) (#xF6EE #xE515) (#xF6ED #xE514) (#xF6EC #xE513) (#xF6EB #xE512) (#xF6EA #xE511) (#xF6E9 #xE510) (#xF6E8 #xE50F) (#xF6E7 #xE50E) (#xF6E6 #xE50D) (#xF6E5 #xE50C) (#xF6E4 #xE50B) (#xF6E3 #xE50A) (#xF6E2 #xE509) (#xF6E1 #xE508) (#xF6E0 #xE507) (#xF6DF #xE506) (#xF6DE #xE505) (#xF6DD #xE504) (#xF6DC #xE503) (#xF6DB #xE502) (#xF6DA #xE501) (#xF6D9 #xE500) (#xF6D8 #xE4FF) (#xF6D7 #xE4FE) (#xF6D6 #xE4FD) (#xF6D5 #xE4FC) (#xF6D4 #xE4FB) (#xF6D3 #xE4FA) (#xF6D2 #xE4F9) (#xF6D1 #xE4F8) (#xF6D0 #xE4F7) (#xF6CF #xE4F6) (#xF6CE #xE4F5) (#xF6CD #xE4F4) (#xF6CC #xE4F3) (#xF6CB #xE4F2) (#xF6CA #xE4F1) (#xF6C9 #xE4F0) (#xF6C8 #xE4EF) (#xF6C7 #xE4EE) (#xF6C6 #xE4ED) (#xF6C5 #xE4EC) (#xF6C4 #xE4EB) (#xF6C3 #xE4EA) (#xF6C2 #xE4E9) (#xF6C1 #xE4E8) (#xF6C0 #xE4E7) (#xF6BF #xE4E6) (#xF6BE #xE4E5) (#xF6BD #xE4E4) (#xF6BC #xE4E3) (#xF6BB #xE4E2) (#xF6BA #xE4E1) (#xF6B9 #xE4E0) (#xF6B8 #xE4DF) (#xF6B7 #xE4DE) (#xF6B6 #xE4DD) (#xF6B5 #xE4DC) (#xF6B4 #xE4DB) (#xF6B3 #xE4DA) (#xF6B2 #xE4D9) (#xF6B1 #xE4D8) (#xF6B0 #xE4D7) (#xF6AF #xE4D6) (#xF6AE #xE4D5) (#xF6AD #xE4D4) (#xF6AC #xE4D3) (#xF6AB #xE4D2) (#xF6AA #xE4D1) (#xF6A9 #xE4D0) (#xF6A8 #xE4CF) (#xF6A7 #xE4CE) (#xF6A6 #xE4CD) (#xF6A5 #xE4CC) (#xF6A4 #xE4CB) (#xF6A3 #xE4CA) (#xF6A2 #xE4C9) (#xF6A1 #xE4C8) (#xF6A0 #xE4C7) (#xF69F #xE4C6) (#xF69E #xE4C5) (#xF69D #xE4C4) (#xF69C #xE4C3) (#xF69B #xE4C2) (#xF69A #xE4C1) (#xF699 #xE4C0) (#xF698 #xE4BF) (#xF697 #xE4BE) (#xF696 #xE4BD) (#xF695 #xE4BC) (#xF694 #xE4BB) (#xF693 #xE4BA) (#xF692 #xE4B9) (#xF691 #xE4B8) (#xF690 #xE4B7) (#xF68F #xE4B6) (#xF68E #xE4B5) (#xF68D #xE4B4) (#xF68C #xE4B3) (#xF68B #xE4B2) (#xF68A #xE4B1) (#xF689 #xE4B0) (#xF688 #xE4AF) (#xF687 #xE4AE) (#xF686 #xE4AD) (#xF685 #xE4AC) (#xF684 #xE4AB) (#xF683 #xE4AA) (#xF682 #xE4A9) (#xF681 #xE4A8) (#xF680 #xE4A7) (#xF67E #xE4A6) (#xF67D #xE4A5) (#xF67C #xE4A4) (#xF67B #xE4A3) (#xF67A #xE4A2) (#xF679 #xE4A1) (#xF678 #xE4A0) (#xF677 #xE49F) (#xF676 #xE49E) (#xF675 #xE49D) (#xF674 #xE49C) (#xF673 #xE49B) (#xF672 #xE49A) (#xF671 #xE499) (#xF670 #xE498) (#xF66F #xE497) (#xF66E #xE496) (#xF66D #xE495) (#xF66C #xE494) (#xF66B #xE493) (#xF66A #xE492) (#xF669 #xE491) (#xF668 #xE490) (#xF667 #xE48F) (#xF666 #xE48E) (#xF665 #xE48D) (#xF664 #xE48C) (#xF663 #xE48B) (#xF662 #xE48A) (#xF661 #xE489) (#xF660 #xE488) (#xF65F #xE487) (#xF65E #xE486) (#xF65D #xE485) (#xF65C #xE484) (#xF65B #xE483) (#xF65A #xE482) (#xF659 #xE481) (#xF658 #xE480) (#xF657 #xE47F) (#xF656 #xE47E) (#xF655 #xE47D) (#xF654 #xE47C) (#xF653 #xE47B) (#xF652 #xE47A) (#xF651 #xE479) (#xF650 #xE478) (#xF64F #xE477) (#xF64E #xE476) (#xF64D #xE475) (#xF64C #xE474) (#xF64B #xE473) (#xF64A #xE472) (#xF649 #xE471) (#xF648 #xE470) (#xF647 #xE46F) (#xF646 #xE46E) (#xF645 #xE46D) (#xF644 #xE46C) (#xF643 #xE46B) (#xF642 #xE46A) (#xF641 #xE469) (#xF640 #xE468) (#xF5FC #xE467) (#xF5FB #xE466) (#xF5FA #xE465) (#xF5F9 #xE464) (#xF5F8 #xE463) (#xF5F7 #xE462) (#xF5F6 #xE461) (#xF5F5 #xE460) (#xF5F4 #xE45F) (#xF5F3 #xE45E) (#xF5F2 #xE45D) (#xF5F1 #xE45C) (#xF5F0 #xE45B) (#xF5EF #xE45A) (#xF5EE #xE459) (#xF5ED #xE458) (#xF5EC #xE457) (#xF5EB #xE456) (#xF5EA #xE455) (#xF5E9 #xE454) (#xF5E8 #xE453) (#xF5E7 #xE452) (#xF5E6 #xE451) (#xF5E5 #xE450) (#xF5E4 #xE44F) (#xF5E3 #xE44E) (#xF5E2 #xE44D) (#xF5E1 #xE44C) (#xF5E0 #xE44B) (#xF5DF #xE44A) (#xF5DE #xE449) (#xF5DD #xE448) (#xF5DC #xE447) (#xF5DB #xE446) (#xF5DA #xE445) (#xF5D9 #xE444) (#xF5D8 #xE443) (#xF5D7 #xE442) (#xF5D6 #xE441) (#xF5D5 #xE440) (#xF5D4 #xE43F) (#xF5D3 #xE43E) (#xF5D2 #xE43D) (#xF5D1 #xE43C) (#xF5D0 #xE43B) (#xF5CF #xE43A) (#xF5CE #xE439) (#xF5CD #xE438) (#xF5CC #xE437) (#xF5CB #xE436) (#xF5CA #xE435) (#xF5C9 #xE434) (#xF5C8 #xE433) (#xF5C7 #xE432) (#xF5C6 #xE431) (#xF5C5 #xE430) (#xF5C4 #xE42F) (#xF5C3 #xE42E) (#xF5C2 #xE42D) (#xF5C1 #xE42C) (#xF5C0 #xE42B) (#xF5BF #xE42A) (#xF5BE #xE429) (#xF5BD #xE428) (#xF5BC #xE427) (#xF5BB #xE426) (#xF5BA #xE425) (#xF5B9 #xE424) (#xF5B8 #xE423) (#xF5B7 #xE422) (#xF5B6 #xE421) (#xF5B5 #xE420) (#xF5B4 #xE41F) (#xF5B3 #xE41E) (#xF5B2 #xE41D) (#xF5B1 #xE41C) (#xF5B0 #xE41B) (#xF5AF #xE41A) (#xF5AE #xE419) (#xF5AD #xE418) (#xF5AC #xE417) (#xF5AB #xE416) (#xF5AA #xE415) (#xF5A9 #xE414) (#xF5A8 #xE413) (#xF5A7 #xE412) (#xF5A6 #xE411) (#xF5A5 #xE410) (#xF5A4 #xE40F) (#xF5A3 #xE40E) (#xF5A2 #xE40D) (#xF5A1 #xE40C) (#xF5A0 #xE40B) (#xF59F #xE40A) (#xF59E #xE409) (#xF59D #xE408) (#xF59C #xE407) (#xF59B #xE406) (#xF59A #xE405) (#xF599 #xE404) (#xF598 #xE403) (#xF597 #xE402) (#xF596 #xE401) (#xF595 #xE400) (#xF594 #xE3FF) (#xF593 #xE3FE) (#xF592 #xE3FD) (#xF591 #xE3FC) (#xF590 #xE3FB) (#xF58F #xE3FA) (#xF58E #xE3F9) (#xF58D #xE3F8) (#xF58C #xE3F7) (#xF58B #xE3F6) (#xF58A #xE3F5) (#xF589 #xE3F4) (#xF588 #xE3F3) (#xF587 #xE3F2) (#xF586 #xE3F1) (#xF585 #xE3F0) (#xF584 #xE3EF) (#xF583 #xE3EE) (#xF582 #xE3ED) (#xF581 #xE3EC) (#xF580 #xE3EB) (#xF57E #xE3EA) (#xF57D #xE3E9) (#xF57C #xE3E8) (#xF57B #xE3E7) (#xF57A #xE3E6) (#xF579 #xE3E5) (#xF578 #xE3E4) (#xF577 #xE3E3) (#xF576 #xE3E2) (#xF575 #xE3E1) (#xF574 #xE3E0) (#xF573 #xE3DF) (#xF572 #xE3DE) (#xF571 #xE3DD) (#xF570 #xE3DC) (#xF56F #xE3DB) (#xF56E #xE3DA) (#xF56D #xE3D9) (#xF56C #xE3D8) (#xF56B #xE3D7) (#xF56A #xE3D6) (#xF569 #xE3D5) (#xF568 #xE3D4) (#xF567 #xE3D3) (#xF566 #xE3D2) (#xF565 #xE3D1) (#xF564 #xE3D0) (#xF563 #xE3CF) (#xF562 #xE3CE) (#xF561 #xE3CD) (#xF560 #xE3CC) (#xF55F #xE3CB) (#xF55E #xE3CA) (#xF55D #xE3C9) (#xF55C #xE3C8) (#xF55B #xE3C7) (#xF55A #xE3C6) (#xF559 #xE3C5) (#xF558 #xE3C4) (#xF557 #xE3C3) (#xF556 #xE3C2) (#xF555 #xE3C1) (#xF554 #xE3C0) (#xF553 #xE3BF) (#xF552 #xE3BE) (#xF551 #xE3BD) (#xF550 #xE3BC) (#xF54F #xE3BB) (#xF54E #xE3BA) (#xF54D #xE3B9) (#xF54C #xE3B8) (#xF54B #xE3B7) (#xF54A #xE3B6) (#xF549 #xE3B5) (#xF548 #xE3B4) (#xF547 #xE3B3) (#xF546 #xE3B2) (#xF545 #xE3B1) (#xF544 #xE3B0) (#xF543 #xE3AF) (#xF542 #xE3AE) (#xF541 #xE3AD) (#xF540 #xE3AC) (#xF4FC #xE3AB) (#xF4FB #xE3AA) (#xF4FA #xE3A9) (#xF4F9 #xE3A8) (#xF4F8 #xE3A7) (#xF4F7 #xE3A6) (#xF4F6 #xE3A5) (#xF4F5 #xE3A4) (#xF4F4 #xE3A3) (#xF4F3 #xE3A2) (#xF4F2 #xE3A1) (#xF4F1 #xE3A0) (#xF4F0 #xE39F) (#xF4EF #xE39E) (#xF4EE #xE39D) (#xF4ED #xE39C) (#xF4EC #xE39B) (#xF4EB #xE39A) (#xF4EA #xE399) (#xF4E9 #xE398) (#xF4E8 #xE397) (#xF4E7 #xE396) (#xF4E6 #xE395) (#xF4E5 #xE394) (#xF4E4 #xE393) (#xF4E3 #xE392) (#xF4E2 #xE391) (#xF4E1 #xE390) (#xF4E0 #xE38F) (#xF4DF #xE38E) (#xF4DE #xE38D) (#xF4DD #xE38C) (#xF4DC #xE38B) (#xF4DB #xE38A) (#xF4DA #xE389) (#xF4D9 #xE388) (#xF4D8 #xE387) (#xF4D7 #xE386) (#xF4D6 #xE385) (#xF4D5 #xE384) (#xF4D4 #xE383) (#xF4D3 #xE382) (#xF4D2 #xE381) (#xF4D1 #xE380) (#xF4D0 #xE37F) (#xF4CF #xE37E) (#xF4CE #xE37D) (#xF4CD #xE37C) (#xF4CC #xE37B) (#xF4CB #xE37A) (#xF4CA #xE379) (#xF4C9 #xE378) (#xF4C8 #xE377) (#xF4C7 #xE376) (#xF4C6 #xE375) (#xF4C5 #xE374) (#xF4C4 #xE373) (#xF4C3 #xE372) (#xF4C2 #xE371) (#xF4C1 #xE370) (#xF4C0 #xE36F) (#xF4BF #xE36E) (#xF4BE #xE36D) (#xF4BD #xE36C) (#xF4BC #xE36B) (#xF4BB #xE36A) (#xF4BA #xE369) (#xF4B9 #xE368) (#xF4B8 #xE367) (#xF4B7 #xE366) (#xF4B6 #xE365) (#xF4B5 #xE364) (#xF4B4 #xE363) (#xF4B3 #xE362) (#xF4B2 #xE361) (#xF4B1 #xE360) (#xF4B0 #xE35F) (#xF4AF #xE35E) (#xF4AE #xE35D) (#xF4AD #xE35C) (#xF4AC #xE35B) (#xF4AB #xE35A) (#xF4AA #xE359) (#xF4A9 #xE358) (#xF4A8 #xE357) (#xF4A7 #xE356) (#xF4A6 #xE355) (#xF4A5 #xE354) (#xF4A4 #xE353) (#xF4A3 #xE352) (#xF4A2 #xE351) (#xF4A1 #xE350) (#xF4A0 #xE34F) (#xF49F #xE34E) (#xF49E #xE34D) (#xF49D #xE34C) (#xF49C #xE34B) (#xF49B #xE34A) (#xF49A #xE349) (#xF499 #xE348) (#xF498 #xE347) (#xF497 #xE346) (#xF496 #xE345) (#xF495 #xE344) (#xF494 #xE343) (#xF493 #xE342) (#xF492 #xE341) (#xF491 #xE340) (#xF490 #xE33F) (#xF48F #xE33E) (#xF48E #xE33D) (#xF48D #xE33C) (#xF48C #xE33B) (#xF48B #xE33A) (#xF48A #xE339) (#xF489 #xE338) (#xF488 #xE337) (#xF487 #xE336) (#xF486 #xE335) (#xF485 #xE334) (#xF484 #xE333) (#xF483 #xE332) (#xF482 #xE331) (#xF481 #xE330) (#xF480 #xE32F) (#xF47E #xE32E) (#xF47D #xE32D) (#xF47C #xE32C) (#xF47B #xE32B) (#xF47A #xE32A) (#xF479 #xE329) (#xF478 #xE328) (#xF477 #xE327) (#xF476 #xE326) (#xF475 #xE325) (#xF474 #xE324) (#xF473 #xE323) (#xF472 #xE322) (#xF471 #xE321) (#xF470 #xE320) (#xF46F #xE31F) (#xF46E #xE31E) (#xF46D #xE31D) (#xF46C #xE31C) (#xF46B #xE31B) (#xF46A #xE31A) (#xF469 #xE319) (#xF468 #xE318) (#xF467 #xE317) (#xF466 #xE316) (#xF465 #xE315) (#xF464 #xE314) (#xF463 #xE313) (#xF462 #xE312) (#xF461 #xE311) (#xF460 #xE310) (#xF45F #xE30F) (#xF45E #xE30E) (#xF45D #xE30D) (#xF45C #xE30C) (#xF45B #xE30B) (#xF45A #xE30A) (#xF459 #xE309) (#xF458 #xE308) (#xF457 #xE307) (#xF456 #xE306) (#xF455 #xE305) (#xF454 #xE304) (#xF453 #xE303) (#xF452 #xE302) (#xF451 #xE301) (#xF450 #xE300) (#xF44F #xE2FF) (#xF44E #xE2FE) (#xF44D #xE2FD) (#xF44C #xE2FC) (#xF44B #xE2FB) (#xF44A #xE2FA) (#xF449 #xE2F9) (#xF448 #xE2F8) (#xF447 #xE2F7) (#xF446 #xE2F6) (#xF445 #xE2F5) (#xF444 #xE2F4) (#xF443 #xE2F3) (#xF442 #xE2F2) (#xF441 #xE2F1) (#xF440 #xE2F0) (#xF3FC #xE2EF) (#xF3FB #xE2EE) (#xF3FA #xE2ED) (#xF3F9 #xE2EC) (#xF3F8 #xE2EB) (#xF3F7 #xE2EA) (#xF3F6 #xE2E9) (#xF3F5 #xE2E8) (#xF3F4 #xE2E7) (#xF3F3 #xE2E6) (#xF3F2 #xE2E5) (#xF3F1 #xE2E4) (#xF3F0 #xE2E3) (#xF3EF #xE2E2) (#xF3EE #xE2E1) (#xF3ED #xE2E0) (#xF3EC #xE2DF) (#xF3EB #xE2DE) (#xF3EA #xE2DD) (#xF3E9 #xE2DC) (#xF3E8 #xE2DB) (#xF3E7 #xE2DA) (#xF3E6 #xE2D9) (#xF3E5 #xE2D8) (#xF3E4 #xE2D7) (#xF3E3 #xE2D6) (#xF3E2 #xE2D5) (#xF3E1 #xE2D4) (#xF3E0 #xE2D3) (#xF3DF #xE2D2) (#xF3DE #xE2D1) (#xF3DD #xE2D0) (#xF3DC #xE2CF) (#xF3DB #xE2CE) (#xF3DA #xE2CD) (#xF3D9 #xE2CC) (#xF3D8 #xE2CB) (#xF3D7 #xE2CA) (#xF3D6 #xE2C9) (#xF3D5 #xE2C8) (#xF3D4 #xE2C7) (#xF3D3 #xE2C6) (#xF3D2 #xE2C5) (#xF3D1 #xE2C4) (#xF3D0 #xE2C3) (#xF3CF #xE2C2) (#xF3CE #xE2C1) (#xF3CD #xE2C0) (#xF3CC #xE2BF) (#xF3CB #xE2BE) (#xF3CA #xE2BD) (#xF3C9 #xE2BC) (#xF3C8 #xE2BB) (#xF3C7 #xE2BA) (#xF3C6 #xE2B9) (#xF3C5 #xE2B8) (#xF3C4 #xE2B7) (#xF3C3 #xE2B6) (#xF3C2 #xE2B5) (#xF3C1 #xE2B4) (#xF3C0 #xE2B3) (#xF3BF #xE2B2) (#xF3BE #xE2B1) (#xF3BD #xE2B0) (#xF3BC #xE2AF) (#xF3BB #xE2AE) (#xF3BA #xE2AD) (#xF3B9 #xE2AC) (#xF3B8 #xE2AB) (#xF3B7 #xE2AA) (#xF3B6 #xE2A9) (#xF3B5 #xE2A8) (#xF3B4 #xE2A7) (#xF3B3 #xE2A6) (#xF3B2 #xE2A5) (#xF3B1 #xE2A4) (#xF3B0 #xE2A3) (#xF3AF #xE2A2) (#xF3AE #xE2A1) (#xF3AD #xE2A0) (#xF3AC #xE29F) (#xF3AB #xE29E) (#xF3AA #xE29D) (#xF3A9 #xE29C) (#xF3A8 #xE29B) (#xF3A7 #xE29A) (#xF3A6 #xE299) (#xF3A5 #xE298) (#xF3A4 #xE297) (#xF3A3 #xE296) (#xF3A2 #xE295) (#xF3A1 #xE294) (#xF3A0 #xE293) (#xF39F #xE292) (#xF39E #xE291) (#xF39D #xE290) (#xF39C #xE28F) (#xF39B #xE28E) (#xF39A #xE28D) (#xF399 #xE28C) (#xF398 #xE28B) (#xF397 #xE28A) (#xF396 #xE289) (#xF395 #xE288) (#xF394 #xE287) (#xF393 #xE286) (#xF392 #xE285) (#xF391 #xE284) (#xF390 #xE283) (#xF38F #xE282) (#xF38E #xE281) (#xF38D #xE280) (#xF38C #xE27F) (#xF38B #xE27E) (#xF38A #xE27D) (#xF389 #xE27C) (#xF388 #xE27B) (#xF387 #xE27A) (#xF386 #xE279) (#xF385 #xE278) (#xF384 #xE277) (#xF383 #xE276) (#xF382 #xE275) (#xF381 #xE274) (#xF380 #xE273) (#xF37E #xE272) (#xF37D #xE271) (#xF37C #xE270) (#xF37B #xE26F) (#xF37A #xE26E) (#xF379 #xE26D) (#xF378 #xE26C) (#xF377 #xE26B) (#xF376 #xE26A) (#xF375 #xE269) (#xF374 #xE268) (#xF373 #xE267) (#xF372 #xE266) (#xF371 #xE265) (#xF370 #xE264) (#xF36F #xE263) (#xF36E #xE262) (#xF36D #xE261) (#xF36C #xE260) (#xF36B #xE25F) (#xF36A #xE25E) (#xF369 #xE25D) (#xF368 #xE25C) (#xF367 #xE25B) (#xF366 #xE25A) (#xF365 #xE259) (#xF364 #xE258) (#xF363 #xE257) (#xF362 #xE256) (#xF361 #xE255) (#xF360 #xE254) (#xF35F #xE253) (#xF35E #xE252) (#xF35D #xE251) (#xF35C #xE250) (#xF35B #xE24F) (#xF35A #xE24E) (#xF359 #xE24D) (#xF358 #xE24C) (#xF357 #xE24B) (#xF356 #xE24A) (#xF355 #xE249) (#xF354 #xE248) (#xF353 #xE247) (#xF352 #xE246) (#xF351 #xE245) (#xF350 #xE244) (#xF34F #xE243) (#xF34E #xE242) (#xF34D #xE241) (#xF34C #xE240) (#xF34B #xE23F) (#xF34A #xE23E) (#xF349 #xE23D) (#xF348 #xE23C) (#xF347 #xE23B) (#xF346 #xE23A) (#xF345 #xE239) (#xF344 #xE238) (#xF343 #xE237) (#xF342 #xE236) (#xF341 #xE235) (#xF340 #xE234) (#xF2FC #xE233) (#xF2FB #xE232) (#xF2FA #xE231) (#xF2F9 #xE230) (#xF2F8 #xE22F) (#xF2F7 #xE22E) (#xF2F6 #xE22D) (#xF2F5 #xE22C) (#xF2F4 #xE22B) (#xF2F3 #xE22A) (#xF2F2 #xE229) (#xF2F1 #xE228) (#xF2F0 #xE227) (#xF2EF #xE226) (#xF2EE #xE225) (#xF2ED #xE224) (#xF2EC #xE223) (#xF2EB #xE222) (#xF2EA #xE221) (#xF2E9 #xE220) (#xF2E8 #xE21F) (#xF2E7 #xE21E) (#xF2E6 #xE21D) (#xF2E5 #xE21C) (#xF2E4 #xE21B) (#xF2E3 #xE21A) (#xF2E2 #xE219) (#xF2E1 #xE218) (#xF2E0 #xE217) (#xF2DF #xE216) (#xF2DE #xE215) (#xF2DD #xE214) (#xF2DC #xE213) (#xF2DB #xE212) (#xF2DA #xE211) (#xF2D9 #xE210) (#xF2D8 #xE20F) (#xF2D7 #xE20E) (#xF2D6 #xE20D) (#xF2D5 #xE20C) (#xF2D4 #xE20B) (#xF2D3 #xE20A) (#xF2D2 #xE209) (#xF2D1 #xE208) (#xF2D0 #xE207) (#xF2CF #xE206) (#xF2CE #xE205) (#xF2CD #xE204) (#xF2CC #xE203) (#xF2CB #xE202) (#xF2CA #xE201) (#xF2C9 #xE200) (#xF2C8 #xE1FF) (#xF2C7 #xE1FE) (#xF2C6 #xE1FD) (#xF2C5 #xE1FC) (#xF2C4 #xE1FB) (#xF2C3 #xE1FA) (#xF2C2 #xE1F9) (#xF2C1 #xE1F8) (#xF2C0 #xE1F7) (#xF2BF #xE1F6) (#xF2BE #xE1F5) (#xF2BD #xE1F4) (#xF2BC #xE1F3) (#xF2BB #xE1F2) (#xF2BA #xE1F1) (#xF2B9 #xE1F0) (#xF2B8 #xE1EF) (#xF2B7 #xE1EE) (#xF2B6 #xE1ED) (#xF2B5 #xE1EC) (#xF2B4 #xE1EB) (#xF2B3 #xE1EA) (#xF2B2 #xE1E9) (#xF2B1 #xE1E8) (#xF2B0 #xE1E7) (#xF2AF #xE1E6) (#xF2AE #xE1E5) (#xF2AD #xE1E4) (#xF2AC #xE1E3) (#xF2AB #xE1E2) (#xF2AA #xE1E1) (#xF2A9 #xE1E0) (#xF2A8 #xE1DF) (#xF2A7 #xE1DE) (#xF2A6 #xE1DD) (#xF2A5 #xE1DC) (#xF2A4 #xE1DB) (#xF2A3 #xE1DA) (#xF2A2 #xE1D9) (#xF2A1 #xE1D8) (#xF2A0 #xE1D7) (#xF29F #xE1D6) (#xF29E #xE1D5) (#xF29D #xE1D4) (#xF29C #xE1D3) (#xF29B #xE1D2) (#xF29A #xE1D1) (#xF299 #xE1D0) (#xF298 #xE1CF) (#xF297 #xE1CE) (#xF296 #xE1CD) (#xF295 #xE1CC) (#xF294 #xE1CB) (#xF293 #xE1CA) (#xF292 #xE1C9) (#xF291 #xE1C8) (#xF290 #xE1C7) (#xF28F #xE1C6) (#xF28E #xE1C5) (#xF28D #xE1C4) (#xF28C #xE1C3) (#xF28B #xE1C2) (#xF28A #xE1C1) (#xF289 #xE1C0) (#xF288 #xE1BF) (#xF287 #xE1BE) (#xF286 #xE1BD) (#xF285 #xE1BC) (#xF284 #xE1BB) (#xF283 #xE1BA) (#xF282 #xE1B9) (#xF281 #xE1B8) (#xF280 #xE1B7) (#xF27E #xE1B6) (#xF27D #xE1B5) (#xF27C #xE1B4) (#xF27B #xE1B3) (#xF27A #xE1B2) (#xF279 #xE1B1) (#xF278 #xE1B0) (#xF277 #xE1AF) (#xF276 #xE1AE) (#xF275 #xE1AD) (#xF274 #xE1AC) (#xF273 #xE1AB) (#xF272 #xE1AA) (#xF271 #xE1A9) (#xF270 #xE1A8) (#xF26F #xE1A7) (#xF26E #xE1A6) (#xF26D #xE1A5) (#xF26C #xE1A4) (#xF26B #xE1A3) (#xF26A #xE1A2) (#xF269 #xE1A1) (#xF268 #xE1A0) (#xF267 #xE19F) (#xF266 #xE19E) (#xF265 #xE19D) (#xF264 #xE19C) (#xF263 #xE19B) (#xF262 #xE19A) (#xF261 #xE199) (#xF260 #xE198) (#xF25F #xE197) (#xF25E #xE196) (#xF25D #xE195) (#xF25C #xE194) (#xF25B #xE193) (#xF25A #xE192) (#xF259 #xE191) (#xF258 #xE190) (#xF257 #xE18F) (#xF256 #xE18E) (#xF255 #xE18D) (#xF254 #xE18C) (#xF253 #xE18B) (#xF252 #xE18A) (#xF251 #xE189) (#xF250 #xE188) (#xF24F #xE187) (#xF24E #xE186) (#xF24D #xE185) (#xF24C #xE184) (#xF24B #xE183) (#xF24A #xE182) (#xF249 #xE181) (#xF248 #xE180) (#xF247 #xE17F) (#xF246 #xE17E) (#xF245 #xE17D) (#xF244 #xE17C) (#xF243 #xE17B) (#xF242 #xE17A) (#xF241 #xE179) (#xF240 #xE178) (#xF1FC #xE177) (#xF1FB #xE176) (#xF1FA #xE175) (#xF1F9 #xE174) (#xF1F8 #xE173) (#xF1F7 #xE172) (#xF1F6 #xE171) (#xF1F5 #xE170) (#xF1F4 #xE16F) (#xF1F3 #xE16E) (#xF1F2 #xE16D) (#xF1F1 #xE16C) (#xF1F0 #xE16B) (#xF1EF #xE16A) (#xF1EE #xE169) (#xF1ED #xE168) (#xF1EC #xE167) (#xF1EB #xE166) (#xF1EA #xE165) (#xF1E9 #xE164) (#xF1E8 #xE163) (#xF1E7 #xE162) (#xF1E6 #xE161) (#xF1E5 #xE160) (#xF1E4 #xE15F) (#xF1E3 #xE15E) (#xF1E2 #xE15D) (#xF1E1 #xE15C) (#xF1E0 #xE15B) (#xF1DF #xE15A) (#xF1DE #xE159) (#xF1DD #xE158) (#xF1DC #xE157) (#xF1DB #xE156) (#xF1DA #xE155) (#xF1D9 #xE154) (#xF1D8 #xE153) (#xF1D7 #xE152) (#xF1D6 #xE151) (#xF1D5 #xE150) (#xF1D4 #xE14F) (#xF1D3 #xE14E) (#xF1D2 #xE14D) (#xF1D1 #xE14C) (#xF1D0 #xE14B) (#xF1CF #xE14A) (#xF1CE #xE149) (#xF1CD #xE148) (#xF1CC #xE147) (#xF1CB #xE146) (#xF1CA #xE145) (#xF1C9 #xE144) (#xF1C8 #xE143) (#xF1C7 #xE142) (#xF1C6 #xE141) (#xF1C5 #xE140) (#xF1C4 #xE13F) (#xF1C3 #xE13E) (#xF1C2 #xE13D) (#xF1C1 #xE13C) (#xF1C0 #xE13B) (#xF1BF #xE13A) (#xF1BE #xE139) (#xF1BD #xE138) (#xF1BC #xE137) (#xF1BB #xE136) (#xF1BA #xE135) (#xF1B9 #xE134) (#xF1B8 #xE133) (#xF1B7 #xE132) (#xF1B6 #xE131) (#xF1B5 #xE130) (#xF1B4 #xE12F) (#xF1B3 #xE12E) (#xF1B2 #xE12D) (#xF1B1 #xE12C) (#xF1B0 #xE12B) (#xF1AF #xE12A) (#xF1AE #xE129) (#xF1AD #xE128) (#xF1AC #xE127) (#xF1AB #xE126) (#xF1AA #xE125) (#xF1A9 #xE124) (#xF1A8 #xE123) (#xF1A7 #xE122) (#xF1A6 #xE121) (#xF1A5 #xE120) (#xF1A4 #xE11F) (#xF1A3 #xE11E) (#xF1A2 #xE11D) (#xF1A1 #xE11C) (#xF1A0 #xE11B) (#xF19F #xE11A) (#xF19E #xE119) (#xF19D #xE118) (#xF19C #xE117) (#xF19B #xE116) (#xF19A #xE115) (#xF199 #xE114) (#xF198 #xE113) (#xF197 #xE112) (#xF196 #xE111) (#xF195 #xE110) (#xF194 #xE10F) (#xF193 #xE10E) (#xF192 #xE10D) (#xF191 #xE10C) (#xF190 #xE10B) (#xF18F #xE10A) (#xF18E #xE109) (#xF18D #xE108) (#xF18C #xE107) (#xF18B #xE106) (#xF18A #xE105) (#xF189 #xE104) (#xF188 #xE103) (#xF187 #xE102) (#xF186 #xE101) (#xF185 #xE100) (#xF184 #xE0FF) (#xF183 #xE0FE) (#xF182 #xE0FD) (#xF181 #xE0FC) (#xF180 #xE0FB) (#xF17E #xE0FA) (#xF17D #xE0F9) (#xF17C #xE0F8) (#xF17B #xE0F7) (#xF17A #xE0F6) (#xF179 #xE0F5) (#xF178 #xE0F4) (#xF177 #xE0F3) (#xF176 #xE0F2) (#xF175 #xE0F1) (#xF174 #xE0F0) (#xF173 #xE0EF) (#xF172 #xE0EE) (#xF171 #xE0ED) (#xF170 #xE0EC) (#xF16F #xE0EB) (#xF16E #xE0EA) (#xF16D #xE0E9) (#xF16C #xE0E8) (#xF16B #xE0E7) (#xF16A #xE0E6) (#xF169 #xE0E5) (#xF168 #xE0E4) (#xF167 #xE0E3) (#xF166 #xE0E2) (#xF165 #xE0E1) (#xF164 #xE0E0) (#xF163 #xE0DF) (#xF162 #xE0DE) (#xF161 #xE0DD) (#xF160 #xE0DC) (#xF15F #xE0DB) (#xF15E #xE0DA) (#xF15D #xE0D9) (#xF15C #xE0D8) (#xF15B #xE0D7) (#xF15A #xE0D6) (#xF159 #xE0D5) (#xF158 #xE0D4) (#xF157 #xE0D3) (#xF156 #xE0D2) (#xF155 #xE0D1) (#xF154 #xE0D0) (#xF153 #xE0CF) (#xF152 #xE0CE) (#xF151 #xE0CD) (#xF150 #xE0CC) (#xF14F #xE0CB) (#xF14E #xE0CA) (#xF14D #xE0C9) (#xF14C #xE0C8) (#xF14B #xE0C7) (#xF14A #xE0C6) (#xF149 #xE0C5) (#xF148 #xE0C4) (#xF147 #xE0C3) (#xF146 #xE0C2) (#xF145 #xE0C1) (#xF144 #xE0C0) (#xF143 #xE0BF) (#xF142 #xE0BE) (#xF141 #xE0BD) (#xF140 #xE0BC) (#xF0FC #xE0BB) (#xF0FB #xE0BA) (#xF0FA #xE0B9) (#xF0F9 #xE0B8) (#xF0F8 #xE0B7) (#xF0F7 #xE0B6) (#xF0F6 #xE0B5) (#xF0F5 #xE0B4) (#xF0F4 #xE0B3) (#xF0F3 #xE0B2) (#xF0F2 #xE0B1) (#xF0F1 #xE0B0) (#xF0F0 #xE0AF) (#xF0EF #xE0AE) (#xF0EE #xE0AD) (#xF0ED #xE0AC) (#xF0EC #xE0AB) (#xF0EB #xE0AA) (#xF0EA #xE0A9) (#xF0E9 #xE0A8) (#xF0E8 #xE0A7) (#xF0E7 #xE0A6) (#xF0E6 #xE0A5) (#xF0E5 #xE0A4) (#xF0E4 #xE0A3) (#xF0E3 #xE0A2) (#xF0E2 #xE0A1) (#xF0E1 #xE0A0) (#xF0E0 #xE09F) (#xF0DF #xE09E) (#xF0DE #xE09D) (#xF0DD #xE09C) (#xF0DC #xE09B) (#xF0DB #xE09A) (#xF0DA #xE099) (#xF0D9 #xE098) (#xF0D8 #xE097) (#xF0D7 #xE096) (#xF0D6 #xE095) (#xF0D5 #xE094) (#xF0D4 #xE093) (#xF0D3 #xE092) (#xF0D2 #xE091) (#xF0D1 #xE090) (#xF0D0 #xE08F) (#xF0CF #xE08E) (#xF0CE #xE08D) (#xF0CD #xE08C) (#xF0CC #xE08B) (#xF0CB #xE08A) (#xF0CA #xE089) (#xF0C9 #xE088) (#xF0C8 #xE087) (#xF0C7 #xE086) (#xF0C6 #xE085) (#xF0C5 #xE084) (#xF0C4 #xE083) (#xF0C3 #xE082) (#xF0C2 #xE081) (#xF0C1 #xE080) (#xF0C0 #xE07F) (#xF0BF #xE07E) (#xF0BE #xE07D) (#xF0BD #xE07C) (#xF0BC #xE07B) (#xF0BB #xE07A) (#xF0BA #xE079) (#xF0B9 #xE078) (#xF0B8 #xE077) (#xF0B7 #xE076) (#xF0B6 #xE075) (#xF0B5 #xE074) (#xF0B4 #xE073) (#xF0B3 #xE072) (#xF0B2 #xE071) (#xF0B1 #xE070) (#xF0B0 #xE06F) (#xF0AF #xE06E) (#xF0AE #xE06D) (#xF0AD #xE06C) (#xF0AC #xE06B) (#xF0AB #xE06A) (#xF0AA #xE069) (#xF0A9 #xE068) (#xF0A8 #xE067) (#xF0A7 #xE066) (#xF0A6 #xE065) (#xF0A5 #xE064) (#xF0A4 #xE063) (#xF0A3 #xE062) (#xF0A2 #xE061) (#xF0A1 #xE060) (#xF0A0 #xE05F) (#xF09F #xE05E) (#xF09E #xE05D) (#xF09D #xE05C) (#xF09C #xE05B) (#xF09B #xE05A) (#xF09A #xE059) (#xF099 #xE058) (#xF098 #xE057) (#xF097 #xE056) (#xF096 #xE055) (#xF095 #xE054) (#xF094 #xE053) (#xF093 #xE052) (#xF092 #xE051) (#xF091 #xE050) (#xF090 #xE04F) (#xF08F #xE04E) (#xF08E #xE04D) (#xF08D #xE04C) (#xF08C #xE04B) (#xF08B #xE04A) (#xF08A #xE049) (#xF089 #xE048) (#xF088 #xE047) (#xF087 #xE046) (#xF086 #xE045) (#xF085 #xE044) (#xF084 #xE043) (#xF083 #xE042) (#xF082 #xE041) (#xF081 #xE040) (#xF080 #xE03F) (#xF07E #xE03E) (#xF07D #xE03D) (#xF07C #xE03C) (#xF07B #xE03B) (#xF07A #xE03A) (#xF079 #xE039) (#xF078 #xE038) (#xF077 #xE037) (#xF076 #xE036) (#xF075 #xE035) (#xF074 #xE034) (#xF073 #xE033) (#xF072 #xE032) (#xF071 #xE031) (#xF070 #xE030) (#xF06F #xE02F) (#xF06E #xE02E) (#xF06D #xE02D) (#xF06C #xE02C) (#xF06B #xE02B) (#xF06A #xE02A) (#xF069 #xE029) (#xF068 #xE028) (#xF067 #xE027) (#xF066 #xE026) (#xF065 #xE025) (#xF064 #xE024) (#xF063 #xE023) (#xF062 #xE022) (#xF061 #xE021) (#xF060 #xE020) (#xF05F #xE01F) (#xF05E #xE01E) (#xF05D #xE01D) (#xF05C #xE01C) (#xF05B #xE01B) (#xF05A #xE01A) (#xF059 #xE019) (#xF058 #xE018) (#xF057 #xE017) (#xF056 #xE016) (#xF055 #xE015) (#xF054 #xE014) (#xF053 #xE013) (#xF052 #xE012) (#xF051 #xE011) (#xF050 #xE010) (#xF04F #xE00F) (#xF04E #xE00E) (#xF04D #xE00D) (#xF04C #xE00C) (#xF04B #xE00B) (#xF04A #xE00A) (#xF049 #xE009) (#xF048 #xE008) (#xF047 #xE007) (#xF046 #xE006) (#xF045 #xE005) (#xF044 #xE004) (#xF043 #xE003) (#xF042 #xE002) (#xF041 #xE001) (#xF040 #xE000) (#xEEFC #xFF02) (#xEEFB #xFF07) (#xEEFA #xFFE4) (#xEEF9 #xFFE2) (#xEEF8 #x2179) (#xEEF7 #x2178) (#xEEF6 #x2177) (#xEEF5 #x2176) (#xEEF4 #x2175) (#xEEF3 #x2174) (#xEEF2 #x2173) (#xEEF1 #x2172) (#xEEF0 #x2171) (#xEEEF #x2170) (#xEEEC #x9ED1) (#xEEEB #x9E19) (#xEEEA #xFA2D) (#xEEE9 #x9D6B) (#xEEE8 #x9D70) (#xEEE7 #x9C00) (#xEEE6 #x9BBB) (#xEEE5 #x9BB1) (#xEEE4 #x9B8F) (#xEEE3 #x9B72) (#xEEE2 #x9B75) (#xEEE1 #x9ADC) (#xEEE0 #x9AD9) (#xEEDF #x9A4E) (#xEEDE #x999E) (#xEEDD #xFA2C) (#xEEDC #x9927) (#xEEDB #xFA2B) (#xEEDA #xFA2A) (#xEED9 #x9865) (#xEED8 #x9857) (#xEED7 #x9755) (#xEED6 #x9751) (#xEED5 #x974F) (#xEED4 #x974D) (#xEED3 #x9743) (#xEED2 #x973B) (#xEED1 #x9733) (#xEED0 #x96AF) (#xEECF #x969D) (#xEECE #xFA29) (#xEECD #xF9DC) (#xEECC #x9592) (#xEECB #x9448) (#xEECA #x9445) (#xEEC9 #x9431) (#xEEC8 #x93F8) (#xEEC7 #x93DE) (#xEEC6 #x93C6) (#xEEC5 #x93A4) (#xEEC4 #x9357) (#xEEC3 #x9370) (#xEEC2 #x9302) (#xEEC1 #x931D) (#xEEC0 #x92FF) (#xEEBF #x931E) (#xEEBE #xFA28) (#xEEBD #x92FB) (#xEEBC #x9321) (#xEEBB #x9325) (#xEEBA #x92D3) (#xEEB9 #x92E0) (#xEEB8 #x92D5) (#xEEB7 #xFA27) (#xEEB6 #x92D0) (#xEEB5 #x92D9) (#xEEB4 #x92D7) (#xEEB3 #x92E7) (#xEEB2 #x9278) (#xEEB1 #x9277) (#xEEB0 #x92A7) (#xEEAF #x9267) (#xEEAE #x9239) (#xEEAD #x9251) (#xEEAC #x9259) (#xEEAB #x924E) (#xEEAA #x923C) (#xEEA9 #x9240) (#xEEA8 #x923A) (#xEEA7 #x920A) (#xEEA6 #x9210) (#xEEA5 #x9206) (#xEEA4 #x91E5) (#xEEA3 #x91E4) (#xEEA2 #x91EE) (#xEEA1 #x91ED) (#xEEA0 #x91DE) (#xEE9F #x91D7) (#xEE9E #x91DA) (#xEE9D #x9127) (#xEE9C #x9115) (#xEE9B #xFA26) (#xEE9A #x90DE) (#xEE99 #x9067) (#xEE98 #xFA25) (#xEE97 #xFA24) (#xEE96 #x8ECF) (#xEE95 #xFA23) (#xEE94 #x8D76) (#xEE93 #x8D12) (#xEE92 #x8CF4) (#xEE91 #x8CF0) (#xEE90 #x8B7F) (#xEE8F #x8B53) (#xEE8E #x8AF6) (#xEE8D #xFA22) (#xEE8C #x8ADF) (#xEE8B #x8ABE) (#xEE8A #x8AA7) (#xEE89 #x8A79) (#xEE88 #x8A37) (#xEE87 #x8A12) (#xEE86 #x88F5) (#xEE85 #x8807) (#xEE84 #xFA21) (#xEE83 #xFA20) (#xEE82 #x85B0) (#xEE81 #xFA1F) (#xEE80 #x856B) (#xEE7E #x8559) (#xEE7D #x8553) (#xEE7C #x84B4) (#xEE7B #x8448) (#xEE7A #x83F6) (#xEE79 #x83C7) (#xEE78 #x837F) (#xEE77 #x8362) (#xEE76 #x8301) (#xEE75 #xFA1E) (#xEE74 #x7FA1) (#xEE73 #x7F47) (#xEE72 #x7E52) (#xEE71 #x7DD6) (#xEE70 #x7DA0) (#xEE6F #x7DB7) (#xEE6E #x7D5C) (#xEE6D #x7D48) (#xEE6C #xFA1D) (#xEE6B #x7B9E) (#xEE6A #x7AEB) (#xEE69 #xFA1C) (#xEE68 #x7AE7) (#xEE67 #x7AD1) (#xEE66 #x799B) (#xEE65 #xFA1B) (#xEE64 #x7994) (#xEE63 #xFA1A) (#xEE62 #xFA19) (#xEE61 #xFA18) (#xEE60 #x7930) (#xEE5F #x787A) (#xEE5E #x7864) (#xEE5D #x784E) (#xEE5C #x7821) (#xEE5B #x52AF) (#xEE5A #x7746) (#xEE59 #xFA17) (#xEE58 #x76A6) (#xEE57 #x769B) (#xEE56 #x769E) (#xEE55 #x769C) (#xEE54 #x7682) (#xEE53 #x756F) (#xEE52 #x7501) (#xEE51 #x749F) (#xEE50 #x7489) (#xEE4F #x7462) (#xEE4E #x742E) (#xEE4D #x7429) (#xEE4C #x742A) (#xEE4B #x7426) (#xEE4A #x73F5) (#xEE49 #x7407) (#xEE48 #x73D2) (#xEE47 #x73E3) (#xEE46 #x73D6) (#xEE45 #x73C9) (#xEE44 #x73BD) (#xEE43 #x7377) (#xEE42 #xFA16) (#xEE41 #x7324) (#xEE40 #x72BE) (#xEDFC #x72B1) (#xEDFB #x71FE) (#xEDFA #x71C1) (#xEDF9 #xFA15) (#xEDF8 #x7147) (#xEDF7 #x7146) (#xEDF6 #x715C) (#xEDF5 #x7104) (#xEDF4 #x710F) (#xEDF3 #x70AB) (#xEDF2 #x7085) (#xEDF1 #x7028) (#xEDF0 #x7007) (#xEDEF #x7005) (#xEDEE #x6FF5) (#xEDED #x6FB5) (#xEDEC #x6F88) (#xEDEB #x6EBF) (#xEDEA #x6E3C) (#xEDE9 #x6E27) (#xEDE8 #x6E5C) (#xEDE7 #x6E39) (#xEDE6 #x6DFC) (#xEDE5 #x6DF2) (#xEDE4 #x6DF8) (#xEDE3 #x6DCF) (#xEDE2 #x6DAC) (#xEDE1 #x6D96) (#xEDE0 #x6D6F) (#xEDDF #x6D87) (#xEDDE #x6D04) (#xEDDD #x6CDA) (#xEDDC #x6C6F) (#xEDDB #x6C86) (#xEDDA #x6C5C) (#xEDD9 #x6C3F) (#xEDD8 #x6BD6) (#xEDD7 #x6AE4) (#xEDD6 #x6AE2) (#xEDD5 #x6A7E) (#xEDD4 #x6A73) (#xEDD3 #x6A46) (#xEDD2 #x6A6B) (#xEDD1 #x6A30) (#xEDD0 #x69E2) (#xEDCF #x6998) (#xEDCE #xFA14) (#xEDCD #x6968) (#xEDCC #xFA13) (#xEDCB #x68CF) (#xEDCA #x6844) (#xEDC9 #x6801) (#xEDC8 #x67C0) (#xEDC7 #x6852) (#xEDC6 #x67BB) (#xEDC5 #x6766) (#xEDC4 #xF929) (#xEDC3 #x670E) (#xEDC2 #x66FA) (#xEDC1 #x66BF) (#xEDC0 #x66B2) (#xEDBF #x66A0) (#xEDBE #x6699) (#xEDBD #x6673) (#xEDBC #xFA12) (#xEDBB #x6659) (#xEDBA #x6657) (#xEDB9 #x6665) (#xEDB8 #x6624) (#xEDB7 #x661E) (#xEDB6 #x662E) (#xEDB5 #x6609) (#xEDB4 #x663B) (#xEDB3 #x6615) (#xEDB2 #x6600) (#xEDB1 #x654E) (#xEDB0 #x64CE) (#xEDAF #x649D) (#xEDAE #x6460) (#xEDAD #x63F5) (#xEDAC #x62A6) (#xEDAB #x6213) (#xEDAA #x6198) (#xEDA9 #x6130) (#xEDA8 #x6137) (#xEDA7 #x6111) (#xEDA6 #x60F2) (#xEDA5 #x6120) (#xEDA4 #x60D5) (#xEDA3 #x60DE) (#xEDA2 #x608A) (#xEDA1 #x6085) (#xEDA0 #x605D) (#xED9F #x5FDE) (#xED9E #x5FB7) (#xED9D #x5F67) (#xED9C #x5F34) (#xED9B #x5F21) (#xED9A #x5DD0) (#xED99 #x5DB9) (#xED98 #x5DB8) (#xED97 #x5D6D) (#xED96 #x5D42) (#xED95 #xFA11) (#xED94 #x5D53) (#xED93 #x5D27) (#xED92 #x5CF5) (#xED91 #x5CBA) (#xED90 #x5CA6) (#xED8F #x5C1E) (#xED8E #x5BEC) (#xED8D #x5BD8) (#xED8C #x752F) (#xED8B #x5BC0) (#xED8A #x5B56) (#xED89 #x59BA) (#xED88 #x59A4) (#xED87 #x5963) (#xED86 #x595D) (#xED85 #x595B) (#xED84 #x5953) (#xED83 #x590B) (#xED82 #x58B2) (#xED81 #x589E) (#xED80 #xFA10) (#xED7E #xFA0F) (#xED7D #x57C7) (#xED7C #x57C8) (#xED7B #x57AC) (#xED7A #x5765) (#xED79 #x5759) (#xED78 #x5586) (#xED77 #x54FF) (#xED76 #x54A9) (#xED75 #x548A) (#xED74 #x549C) (#xED73 #xFA0E) (#xED72 #x53DD) (#xED71 #x53B2) (#xED70 #x5393) (#xED6F #x5372) (#xED6E #x5324) (#xED6D #x5307) (#xED6C #x5300) (#xED6B #x52DB) (#xED6A #x52C0) (#xED69 #x52A6) (#xED68 #x529C) (#xED67 #x5215) (#xED66 #x51EC) (#xED65 #x51BE) (#xED64 #x519D) (#xED63 #x5164) (#xED62 #x514A) (#xED61 #x50D8) (#xED60 #x50F4) (#xED5F #x5094) (#xED5E #x5042) (#xED5D #x5070) (#xED5C #x5046) (#xED5B #x501E) (#xED5A #x4FFF) (#xED59 #x5022) (#xED58 #x5040) (#xED57 #x4FCD) (#xED56 #x4F94) (#xED55 #x4F9A) (#xED54 #x4F8A) (#xED53 #x4F92) (#xED52 #x4F56) (#xED51 #x4F39) (#xED50 #x4F03) (#xED4F #x4F00) (#xED4E #x4EFC) (#xED4D #x4EE1) (#xED4C #x4E28) (#xED4B #x5F45) (#xED4A #x66FB) (#xED49 #x92F9) (#xED48 #x68C8) (#xED47 #x6631) (#xED46 #x70BB) (#xED45 #x4FC9) (#xED44 #x84DC) (#xED43 #x9288) (#xED42 #x9348) (#xED41 #x891C) (#xED40 #x7E8A) (#xEA9E #x9FA0) (#xEA40 #x9D5D) (#xE99E #x9AF7) (#xE940 #x9871) (#xE89E #x965E) (#xE840 #x9319) (#xE79E #x8FF8) (#xE740 #x8E47) (#xE69E #x8B6B) (#xE640 #x8966) (#xE59E #x8759) (#xE540 #x8541) (#xE49E #x82D9) (#xE440 #x968B) (#xE39E #x7F3A) (#xE340 #x7D02) (#xE29E #x7B50) (#xE240 #x78E7) (#xE19E #x7670) (#xE140 #x74E0) (#xE09E #x71FC) (#xE040 #x6F3E) (#x9F9E #x6CBE) (#x9F40 #x6A97) (#x9E9E #x68CD) (#x9E40 #x66C4) (#x9D9E #x64BC) (#x9D40 #x621E) (#x9C9E #x609A) (#x9C40 #x5ED6) (#x9B9E #x5C53) (#x9B40 #x5978) (#x9A9E #x5709) (#x9A40 #x54AB) (#x999E #x8FA8) (#x9940 #x50C9) (#x9840 #x84EE) (#x979E #x7483) (#x9740 #x8AED) (#x969E #x6E80) (#x9640 #x6CD5) (#x959E #x670D) (#x9540 #x9F3B) (#x949E #x9EA6) (#x9440 #x5982) (#x939E #x5230) (#x9340 #x90B8) (#x929E #x5BF5) (#x9240 #x53E9) (#x919E #x618E) (#x9140 #x7E4A) (#x909E #x88FE) (#x9040 #x62ED) (#x8F9E #x511F) (#x8F40 #x5B97) (#x8E9E #x6642) (#x8E40 #x5BDF) (#x8D9E #x8FBC) (#x8D40 #x540E) (#x8C9E #x6372) (#x8C40 #x6398) (#x8B9E #x4EAC) (#x8B40 #x6A5F) (#x8A9E #x8431) (#x8A40 #x9B41) (#x899E #x5FDC) (#x8940 #x9662) (#x879C #x222A) (#x879B #x2229) (#x879A #x2235) (#x8799 #x22BF) (#x8798 #x221F) (#x8797 #x2220) (#x8796 #x22A5) (#x8795 #x221A) (#x8794 #x2211) (#x8793 #x222E) (#x8792 #x222B) (#x8791 #x2261) (#x8790 #x2252) (#x878F #x337C) (#x878E #x337D) (#x878D #x337E) (#x878C #x3239) (#x878B #x3232) (#x878A #x3231) (#x8789 #x32A8) (#x8788 #x32A7) (#x8787 #x32A6) (#x8786 #x32A5) (#x8785 #x32A4) (#x8784 #x2121) (#x8783 #x33CD) (#x8782 #x2116) (#x8781 #x301F) (#x8780 #x301D) (#x877E #x337B) (#x8775 #x33A1) (#x8774 #x33C4) (#x8773 #x338F) (#x8772 #x338E) (#x8771 #x339E) (#x8770 #x339D) (#x876F #x339C) (#x876E #x333B) (#x876D #x334A) (#x876C #x332B) (#x876B #x3323) (#x876A #x3326) (#x8769 #x330D) (#x8768 #x3357) (#x8767 #x3351) (#x8766 #x3336) (#x8765 #x3303) (#x8764 #x3327) (#x8763 #x3318) (#x8762 #x334D) (#x8761 #x3322) (#x8760 #x3314) (#x875F #x3349) (#x875D #x2169) (#x875C #x2168) (#x875B #x2167) (#x875A #x2166) (#x8759 #x2165) (#x8758 #x2164) (#x8757 #x2163) (#x8756 #x2162) (#x8755 #x2161) (#x8754 #x2160) (#x8753 #x2473) (#x8752 #x2472) (#x8751 #x2471) (#x8750 #x2470) (#x874F #x246F) (#x874E #x246E) (#x874D #x246D) (#x874C #x246C) (#x874B #x246B) (#x874A #x246A) (#x8749 #x2469) (#x8748 #x2468) (#x8747 #x2467) (#x8746 #x2466) (#x8745 #x2465) (#x8744 #x2464) (#x8743 #x2463) (#x8742 #x2462) (#x8741 #x2461) (#x8740 #x2460) (#x8440 #x410) (#x8340 #x30A1) (#x819E #x25C7) (#x8140 #x3000) )) (defvar *eucjp-only* '((#xFEFE #xE3AB) (#xFEFD #xE3AA) (#xFEFC #xE3A9) (#xFEFB #xE3A8) (#xFEFA #xE3A7) (#xFEF9 #xE3A6) (#xFEF8 #xE3A5) (#xFEF7 #xE3A4) (#xFEF6 #xE3A3) (#xFEF5 #xE3A2) (#xFEF4 #xE3A1) (#xFEF3 #xE3A0) (#xFEF2 #xE39F) (#xFEF1 #xE39E) (#xFEF0 #xE39D) (#xFEEF #xE39C) (#xFEEE #xE39B) (#xFEED #xE39A) (#xFEEC #xE399) (#xFEEB #xE398) (#xFEEA #xE397) (#xFEE9 #xE396) (#xFEE8 #xE395) (#xFEE7 #xE394) (#xFEE6 #xE393) (#xFEE5 #xE392) (#xFEE4 #xE391) (#xFEE3 #xE390) (#xFEE2 #xE38F) (#xFEE1 #xE38E) (#xFEE0 #xE38D) (#xFEDF #xE38C) (#xFEDE #xE38B) (#xFEDD #xE38A) (#xFEDC #xE389) (#xFEDB #xE388) (#xFEDA #xE387) (#xFED9 #xE386) (#xFED8 #xE385) (#xFED7 #xE384) (#xFED6 #xE383) (#xFED5 #xE382) (#xFED4 #xE381) (#xFED3 #xE380) (#xFED2 #xE37F) (#xFED1 #xE37E) (#xFED0 #xE37D) (#xFECF #xE37C) (#xFECE #xE37B) (#xFECD #xE37A) (#xFECC #xE379) (#xFECB #xE378) (#xFECA #xE377) (#xFEC9 #xE376) (#xFEC8 #xE375) (#xFEC7 #xE374) (#xFEC6 #xE373) (#xFEC5 #xE372) (#xFEC4 #xE371) (#xFEC3 #xE370) (#xFEC2 #xE36F) (#xFEC1 #xE36E) (#xFEC0 #xE36D) (#xFEBF #xE36C) (#xFEBE #xE36B) (#xFEBD #xE36A) (#xFEBC #xE369) (#xFEBB #xE368) (#xFEBA #xE367) (#xFEB9 #xE366) (#xFEB8 #xE365) (#xFEB7 #xE364) (#xFEB6 #xE363) (#xFEB5 #xE362) (#xFEB4 #xE361) (#xFEB3 #xE360) (#xFEB2 #xE35F) (#xFEB1 #xE35E) (#xFEB0 #xE35D) (#xFEAF #xE35C) (#xFEAE #xE35B) (#xFEAD #xE35A) (#xFEAC #xE359) (#xFEAB #xE358) (#xFEAA #xE357) (#xFEA9 #xE356) (#xFEA8 #xE355) (#xFEA7 #xE354) (#xFEA6 #xE353) (#xFEA5 #xE352) (#xFEA4 #xE351) (#xFEA3 #xE350) (#xFEA2 #xE34F) (#xFEA1 #xE34E) (#xFDFE #xE34D) (#xFDFD #xE34C) (#xFDFC #xE34B) (#xFDFB #xE34A) (#xFDFA #xE349) (#xFDF9 #xE348) (#xFDF8 #xE347) (#xFDF7 #xE346) (#xFDF6 #xE345) (#xFDF5 #xE344) (#xFDF4 #xE343) (#xFDF3 #xE342) (#xFDF2 #xE341) (#xFDF1 #xE340) (#xFDF0 #xE33F) (#xFDEF #xE33E) (#xFDEE #xE33D) (#xFDED #xE33C) (#xFDEC #xE33B) (#xFDEB #xE33A) (#xFDEA #xE339) (#xFDE9 #xE338) (#xFDE8 #xE337) (#xFDE7 #xE336) (#xFDE6 #xE335) (#xFDE5 #xE334) (#xFDE4 #xE333) (#xFDE3 #xE332) (#xFDE2 #xE331) (#xFDE1 #xE330) (#xFDE0 #xE32F) (#xFDDF #xE32E) (#xFDDE #xE32D) (#xFDDD #xE32C) (#xFDDC #xE32B) (#xFDDB #xE32A) (#xFDDA #xE329) (#xFDD9 #xE328) (#xFDD8 #xE327) (#xFDD7 #xE326) (#xFDD6 #xE325) (#xFDD5 #xE324) (#xFDD4 #xE323) (#xFDD3 #xE322) (#xFDD2 #xE321) (#xFDD1 #xE320) (#xFDD0 #xE31F) (#xFDCF #xE31E) (#xFDCE #xE31D) (#xFDCD #xE31C) (#xFDCC #xE31B) (#xFDCB #xE31A) (#xFDCA #xE319) (#xFDC9 #xE318) (#xFDC8 #xE317) (#xFDC7 #xE316) (#xFDC6 #xE315) (#xFDC5 #xE314) (#xFDC4 #xE313) (#xFDC3 #xE312) (#xFDC2 #xE311) (#xFDC1 #xE310) (#xFDC0 #xE30F) (#xFDBF #xE30E) (#xFDBE #xE30D) (#xFDBD #xE30C) (#xFDBC #xE30B) (#xFDBB #xE30A) (#xFDBA #xE309) (#xFDB9 #xE308) (#xFDB8 #xE307) (#xFDB7 #xE306) (#xFDB6 #xE305) (#xFDB5 #xE304) (#xFDB4 #xE303) (#xFDB3 #xE302) (#xFDB2 #xE301) (#xFDB1 #xE300) (#xFDB0 #xE2FF) (#xFDAF #xE2FE) (#xFDAE #xE2FD) (#xFDAD #xE2FC) (#xFDAC #xE2FB) (#xFDAB #xE2FA) (#xFDAA #xE2F9) (#xFDA9 #xE2F8) (#xFDA8 #xE2F7) (#xFDA7 #xE2F6) (#xFDA6 #xE2F5) (#xFDA5 #xE2F4) (#xFDA4 #xE2F3) (#xFDA3 #xE2F2) (#xFDA2 #xE2F1) (#xFDA1 #xE2F0) (#xFCFE #xE2EF) (#xFCFD #xE2EE) (#xFCFC #xE2ED) (#xFCFB #xE2EC) (#xFCFA #xE2EB) (#xFCF9 #xE2EA) (#xFCF8 #xE2E9) (#xFCF7 #xE2E8) (#xFCF6 #xE2E7) (#xFCF5 #xE2E6) (#xFCF4 #xE2E5) (#xFCF3 #xE2E4) (#xFCF2 #xE2E3) (#xFCF1 #xE2E2) (#xFCF0 #xE2E1) (#xFCEF #xE2E0) (#xFCEE #xE2DF) (#xFCED #xE2DE) (#xFCEC #xE2DD) (#xFCEB #xE2DC) (#xFCEA #xE2DB) (#xFCE9 #xE2DA) (#xFCE8 #xE2D9) (#xFCE7 #xE2D8) (#xFCE6 #xE2D7) (#xFCE5 #xE2D6) (#xFCE4 #xE2D5) (#xFCE3 #xE2D4) (#xFCE2 #xE2D3) (#xFCE1 #xE2D2) (#xFCE0 #xE2D1) (#xFCDF #xE2D0) (#xFCDE #xE2CF) (#xFCDD #xE2CE) (#xFCDC #xE2CD) (#xFCDB #xE2CC) (#xFCDA #xE2CB) (#xFCD9 #xE2CA) (#xFCD8 #xE2C9) (#xFCD7 #xE2C8) (#xFCD6 #xE2C7) (#xFCD5 #xE2C6) (#xFCD4 #xE2C5) (#xFCD3 #xE2C4) (#xFCD2 #xE2C3) (#xFCD1 #xE2C2) (#xFCD0 #xE2C1) (#xFCCF #xE2C0) (#xFCCE #xE2BF) (#xFCCD #xE2BE) (#xFCCC #xE2BD) (#xFCCB #xE2BC) (#xFCCA #xE2BB) (#xFCC9 #xE2BA) (#xFCC8 #xE2B9) (#xFCC7 #xE2B8) (#xFCC6 #xE2B7) (#xFCC5 #xE2B6) (#xFCC4 #xE2B5) (#xFCC3 #xE2B4) (#xFCC2 #xE2B3) (#xFCC1 #xE2B2) (#xFCC0 #xE2B1) (#xFCBF #xE2B0) (#xFCBE #xE2AF) (#xFCBD #xE2AE) (#xFCBC #xE2AD) (#xFCBB #xE2AC) (#xFCBA #xE2AB) (#xFCB9 #xE2AA) (#xFCB8 #xE2A9) (#xFCB7 #xE2A8) (#xFCB6 #xE2A7) (#xFCB5 #xE2A6) (#xFCB4 #xE2A5) (#xFCB3 #xE2A4) (#xFCB2 #xE2A3) (#xFCB1 #xE2A2) (#xFCB0 #xE2A1) (#xFCAF #xE2A0) (#xFCAE #xE29F) (#xFCAD #xE29E) (#xFCAC #xE29D) (#xFCAB #xE29C) (#xFCAA #xE29B) (#xFCA9 #xE29A) (#xFCA8 #xE299) (#xFCA7 #xE298) (#xFCA6 #xE297) (#xFCA5 #xE296) (#xFCA4 #xE295) (#xFCA3 #xE294) (#xFCA2 #xE293) (#xFCA1 #xE292) (#xFBFE #xE291) (#xFBFD #xE290) (#xFBFC #xE28F) (#xFBFB #xE28E) (#xFBFA #xE28D) (#xFBF9 #xE28C) (#xFBF8 #xE28B) (#xFBF7 #xE28A) (#xFBF6 #xE289) (#xFBF5 #xE288) (#xFBF4 #xE287) (#xFBF3 #xE286) (#xFBF2 #xE285) (#xFBF1 #xE284) (#xFBF0 #xE283) (#xFBEF #xE282) (#xFBEE #xE281) (#xFBED #xE280) (#xFBEC #xE27F) (#xFBEB #xE27E) (#xFBEA #xE27D) (#xFBE9 #xE27C) (#xFBE8 #xE27B) (#xFBE7 #xE27A) (#xFBE6 #xE279) (#xFBE5 #xE278) (#xFBE4 #xE277) (#xFBE3 #xE276) (#xFBE2 #xE275) (#xFBE1 #xE274) (#xFBE0 #xE273) (#xFBDF #xE272) (#xFBDE #xE271) (#xFBDD #xE270) (#xFBDC #xE26F) (#xFBDB #xE26E) (#xFBDA #xE26D) (#xFBD9 #xE26C) (#xFBD8 #xE26B) (#xFBD7 #xE26A) (#xFBD6 #xE269) (#xFBD5 #xE268) (#xFBD4 #xE267) (#xFBD3 #xE266) (#xFBD2 #xE265) (#xFBD1 #xE264) (#xFBD0 #xE263) (#xFBCF #xE262) (#xFBCE #xE261) (#xFBCD #xE260) (#xFBCC #xE25F) (#xFBCB #xE25E) (#xFBCA #xE25D) (#xFBC9 #xE25C) (#xFBC8 #xE25B) (#xFBC7 #xE25A) (#xFBC6 #xE259) (#xFBC5 #xE258) (#xFBC4 #xE257) (#xFBC3 #xE256) (#xFBC2 #xE255) (#xFBC1 #xE254) (#xFBC0 #xE253) (#xFBBF #xE252) (#xFBBE #xE251) (#xFBBD #xE250) (#xFBBC #xE24F) (#xFBBB #xE24E) (#xFBBA #xE24D) (#xFBB9 #xE24C) (#xFBB8 #xE24B) (#xFBB7 #xE24A) (#xFBB6 #xE249) (#xFBB5 #xE248) (#xFBB4 #xE247) (#xFBB3 #xE246) (#xFBB2 #xE245) (#xFBB1 #xE244) (#xFBB0 #xE243) (#xFBAF #xE242) (#xFBAE #xE241) (#xFBAD #xE240) (#xFBAC #xE23F) (#xFBAB #xE23E) (#xFBAA #xE23D) (#xFBA9 #xE23C) (#xFBA8 #xE23B) (#xFBA7 #xE23A) (#xFBA6 #xE239) (#xFBA5 #xE238) (#xFBA4 #xE237) (#xFBA3 #xE236) (#xFBA2 #xE235) (#xFBA1 #xE234) (#xFAFE #xE233) (#xFAFD #xE232) (#xFAFC #xE231) (#xFAFB #xE230) (#xFAFA #xE22F) (#xFAF9 #xE22E) (#xFAF8 #xE22D) (#xFAF7 #xE22C) (#xFAF6 #xE22B) (#xFAF5 #xE22A) (#xFAF4 #xE229) (#xFAF3 #xE228) (#xFAF2 #xE227) (#xFAF1 #xE226) (#xFAF0 #xE225) (#xFAEF #xE224) (#xFAEE #xE223) (#xFAED #xE222) (#xFAEC #xE221) (#xFAEB #xE220) (#xFAEA #xE21F) (#xFAE9 #xE21E) (#xFAE8 #xE21D) (#xFAE7 #xE21C) (#xFAE6 #xE21B) (#xFAE5 #xE21A) (#xFAE4 #xE219) (#xFAE3 #xE218) (#xFAE2 #xE217) (#xFAE1 #xE216) (#xFAE0 #xE215) (#xFADF #xE214) (#xFADE #xE213) (#xFADD #xE212) (#xFADC #xE211) (#xFADB #xE210) (#xFADA #xE20F) (#xFAD9 #xE20E) (#xFAD8 #xE20D) (#xFAD7 #xE20C) (#xFAD6 #xE20B) (#xFAD5 #xE20A) (#xFAD4 #xE209) (#xFAD3 #xE208) (#xFAD2 #xE207) (#xFAD1 #xE206) (#xFAD0 #xE205) (#xFACF #xE204) (#xFACE #xE203) (#xFACD #xE202) (#xFACC #xE201) (#xFACB #xE200) (#xFACA #xE1FF) (#xFAC9 #xE1FE) (#xFAC8 #xE1FD) (#xFAC7 #xE1FC) (#xFAC6 #xE1FB) (#xFAC5 #xE1FA) (#xFAC4 #xE1F9) (#xFAC3 #xE1F8) (#xFAC2 #xE1F7) (#xFAC1 #xE1F6) (#xFAC0 #xE1F5) (#xFABF #xE1F4) (#xFABE #xE1F3) (#xFABD #xE1F2) (#xFABC #xE1F1) (#xFABB #xE1F0) (#xFABA #xE1EF) (#xFAB9 #xE1EE) (#xFAB8 #xE1ED) (#xFAB7 #xE1EC) (#xFAB6 #xE1EB) (#xFAB5 #xE1EA) (#xFAB4 #xE1E9) (#xFAB3 #xE1E8) (#xFAB2 #xE1E7) (#xFAB1 #xE1E6) (#xFAB0 #xE1E5) (#xFAAF #xE1E4) (#xFAAE #xE1E3) (#xFAAD #xE1E2) (#xFAAC #xE1E1) (#xFAAB #xE1E0) (#xFAAA #xE1DF) (#xFAA9 #xE1DE) (#xFAA8 #xE1DD) (#xFAA7 #xE1DC) (#xFAA6 #xE1DB) (#xFAA5 #xE1DA) (#xFAA4 #xE1D9) (#xFAA3 #xE1D8) (#xFAA2 #xE1D7) (#xFAA1 #xE1D6) (#xF9FE #xE1D5) (#xF9FD #xE1D4) (#xF9FC #xE1D3) (#xF9FB #xE1D2) (#xF9FA #xE1D1) (#xF9F9 #xE1D0) (#xF9F8 #xE1CF) (#xF9F7 #xE1CE) (#xF9F6 #xE1CD) (#xF9F5 #xE1CC) (#xF9F4 #xE1CB) (#xF9F3 #xE1CA) (#xF9F2 #xE1C9) (#xF9F1 #xE1C8) (#xF9F0 #xE1C7) (#xF9EF #xE1C6) (#xF9EE #xE1C5) (#xF9ED #xE1C4) (#xF9EC #xE1C3) (#xF9EB #xE1C2) (#xF9EA #xE1C1) (#xF9E9 #xE1C0) (#xF9E8 #xE1BF) (#xF9E7 #xE1BE) (#xF9E6 #xE1BD) (#xF9E5 #xE1BC) (#xF9E4 #xE1BB) (#xF9E3 #xE1BA) (#xF9E2 #xE1B9) (#xF9E1 #xE1B8) (#xF9E0 #xE1B7) (#xF9DF #xE1B6) (#xF9DE #xE1B5) (#xF9DD #xE1B4) (#xF9DC #xE1B3) (#xF9DB #xE1B2) (#xF9DA #xE1B1) (#xF9D9 #xE1B0) (#xF9D8 #xE1AF) (#xF9D7 #xE1AE) (#xF9D6 #xE1AD) (#xF9D5 #xE1AC) (#xF9D4 #xE1AB) (#xF9D3 #xE1AA) (#xF9D2 #xE1A9) (#xF9D1 #xE1A8) (#xF9D0 #xE1A7) (#xF9CF #xE1A6) (#xF9CE #xE1A5) (#xF9CD #xE1A4) (#xF9CC #xE1A3) (#xF9CB #xE1A2) (#xF9CA #xE1A1) (#xF9C9 #xE1A0) (#xF9C8 #xE19F) (#xF9C7 #xE19E) (#xF9C6 #xE19D) (#xF9C5 #xE19C) (#xF9C4 #xE19B) (#xF9C3 #xE19A) (#xF9C2 #xE199) (#xF9C1 #xE198) (#xF9C0 #xE197) (#xF9BF #xE196) (#xF9BE #xE195) (#xF9BD #xE194) (#xF9BC #xE193) (#xF9BB #xE192) (#xF9BA #xE191) (#xF9B9 #xE190) (#xF9B8 #xE18F) (#xF9B7 #xE18E) (#xF9B6 #xE18D) (#xF9B5 #xE18C) (#xF9B4 #xE18B) (#xF9B3 #xE18A) (#xF9B2 #xE189) (#xF9B1 #xE188) (#xF9B0 #xE187) (#xF9AF #xE186) (#xF9AE #xE185) (#xF9AD #xE184) (#xF9AC #xE183) (#xF9AB #xE182) (#xF9AA #xE181) (#xF9A9 #xE180) (#xF9A8 #xE17F) (#xF9A7 #xE17E) (#xF9A6 #xE17D) (#xF9A5 #xE17C) (#xF9A4 #xE17B) (#xF9A3 #xE17A) (#xF9A2 #xE179) (#xF9A1 #xE178) (#xF8FE #xE177) (#xF8FD #xE176) (#xF8FC #xE175) (#xF8FB #xE174) (#xF8FA #xE173) (#xF8F9 #xE172) (#xF8F8 #xE171) (#xF8F7 #xE170) (#xF8F6 #xE16F) (#xF8F5 #xE16E) (#xF8F4 #xE16D) (#xF8F3 #xE16C) (#xF8F2 #xE16B) (#xF8F1 #xE16A) (#xF8F0 #xE169) (#xF8EF #xE168) (#xF8EE #xE167) (#xF8ED #xE166) (#xF8EC #xE165) (#xF8EB #xE164) (#xF8EA #xE163) (#xF8E9 #xE162) (#xF8E8 #xE161) (#xF8E7 #xE160) (#xF8E6 #xE15F) (#xF8E5 #xE15E) (#xF8E4 #xE15D) (#xF8E3 #xE15C) (#xF8E2 #xE15B) (#xF8E1 #xE15A) (#xF8E0 #xE159) (#xF8DF #xE158) (#xF8DE #xE157) (#xF8DD #xE156) (#xF8DC #xE155) (#xF8DB #xE154) (#xF8DA #xE153) (#xF8D9 #xE152) (#xF8D8 #xE151) (#xF8D7 #xE150) (#xF8D6 #xE14F) (#xF8D5 #xE14E) (#xF8D4 #xE14D) (#xF8D3 #xE14C) (#xF8D2 #xE14B) (#xF8D1 #xE14A) (#xF8D0 #xE149) (#xF8CF #xE148) (#xF8CE #xE147) (#xF8CD #xE146) (#xF8CC #xE145) (#xF8CB #xE144) (#xF8CA #xE143) (#xF8C9 #xE142) (#xF8C8 #xE141) (#xF8C7 #xE140) (#xF8C6 #xE13F) (#xF8C5 #xE13E) (#xF8C4 #xE13D) (#xF8C3 #xE13C) (#xF8C2 #xE13B) (#xF8C1 #xE13A) (#xF8C0 #xE139) (#xF8BF #xE138) (#xF8BE #xE137) (#xF8BD #xE136) (#xF8BC #xE135) (#xF8BB #xE134) (#xF8BA #xE133) (#xF8B9 #xE132) (#xF8B8 #xE131) (#xF8B7 #xE130) (#xF8B6 #xE12F) (#xF8B5 #xE12E) (#xF8B4 #xE12D) (#xF8B3 #xE12C) (#xF8B2 #xE12B) (#xF8B1 #xE12A) (#xF8B0 #xE129) (#xF8AF #xE128) (#xF8AE #xE127) (#xF8AD #xE126) (#xF8AC #xE125) (#xF8AB #xE124) (#xF8AA #xE123) (#xF8A9 #xE122) (#xF8A8 #xE121) (#xF8A7 #xE120) (#xF8A6 #xE11F) (#xF8A5 #xE11E) (#xF8A4 #xE11D) (#xF8A3 #xE11C) (#xF8A2 #xE11B) (#xF8A1 #xE11A) (#xF7FE #xE119) (#xF7FD #xE118) (#xF7FC #xE117) (#xF7FB #xE116) (#xF7FA #xE115) (#xF7F9 #xE114) (#xF7F8 #xE113) (#xF7F7 #xE112) (#xF7F6 #xE111) (#xF7F5 #xE110) (#xF7F4 #xE10F) (#xF7F3 #xE10E) (#xF7F2 #xE10D) (#xF7F1 #xE10C) (#xF7F0 #xE10B) (#xF7EF #xE10A) (#xF7EE #xE109) (#xF7ED #xE108) (#xF7EC #xE107) (#xF7EB #xE106) (#xF7EA #xE105) (#xF7E9 #xE104) (#xF7E8 #xE103) (#xF7E7 #xE102) (#xF7E6 #xE101) (#xF7E5 #xE100) (#xF7E4 #xE0FF) (#xF7E3 #xE0FE) (#xF7E2 #xE0FD) (#xF7E1 #xE0FC) (#xF7E0 #xE0FB) (#xF7DF #xE0FA) (#xF7DE #xE0F9) (#xF7DD #xE0F8) (#xF7DC #xE0F7) (#xF7DB #xE0F6) (#xF7DA #xE0F5) (#xF7D9 #xE0F4) (#xF7D8 #xE0F3) (#xF7D7 #xE0F2) (#xF7D6 #xE0F1) (#xF7D5 #xE0F0) (#xF7D4 #xE0EF) (#xF7D3 #xE0EE) (#xF7D2 #xE0ED) (#xF7D1 #xE0EC) (#xF7D0 #xE0EB) (#xF7CF #xE0EA) (#xF7CE #xE0E9) (#xF7CD #xE0E8) (#xF7CC #xE0E7) (#xF7CB #xE0E6) (#xF7CA #xE0E5) (#xF7C9 #xE0E4) (#xF7C8 #xE0E3) (#xF7C7 #xE0E2) (#xF7C6 #xE0E1) (#xF7C5 #xE0E0) (#xF7C4 #xE0DF) (#xF7C3 #xE0DE) (#xF7C2 #xE0DD) (#xF7C1 #xE0DC) (#xF7C0 #xE0DB) (#xF7BF #xE0DA) (#xF7BE #xE0D9) (#xF7BD #xE0D8) (#xF7BC #xE0D7) (#xF7BB #xE0D6) (#xF7BA #xE0D5) (#xF7B9 #xE0D4) (#xF7B8 #xE0D3) (#xF7B7 #xE0D2) (#xF7B6 #xE0D1) (#xF7B5 #xE0D0) (#xF7B4 #xE0CF) (#xF7B3 #xE0CE) (#xF7B2 #xE0CD) (#xF7B1 #xE0CC) (#xF7B0 #xE0CB) (#xF7AF #xE0CA) (#xF7AE #xE0C9) (#xF7AD #xE0C8) (#xF7AC #xE0C7) (#xF7AB #xE0C6) (#xF7AA #xE0C5) (#xF7A9 #xE0C4) (#xF7A8 #xE0C3) (#xF7A7 #xE0C2) (#xF7A6 #xE0C1) (#xF7A5 #xE0C0) (#xF7A4 #xE0BF) (#xF7A3 #xE0BE) (#xF7A2 #xE0BD) (#xF7A1 #xE0BC) (#xF6FE #xE0BB) (#xF6FD #xE0BA) (#xF6FC #xE0B9) (#xF6FB #xE0B8) (#xF6FA #xE0B7) (#xF6F9 #xE0B6) (#xF6F8 #xE0B5) (#xF6F7 #xE0B4) (#xF6F6 #xE0B3) (#xF6F5 #xE0B2) (#xF6F4 #xE0B1) (#xF6F3 #xE0B0) (#xF6F2 #xE0AF) (#xF6F1 #xE0AE) (#xF6F0 #xE0AD) (#xF6EF #xE0AC) (#xF6EE #xE0AB) (#xF6ED #xE0AA) (#xF6EC #xE0A9) (#xF6EB #xE0A8) (#xF6EA #xE0A7) (#xF6E9 #xE0A6) (#xF6E8 #xE0A5) (#xF6E7 #xE0A4) (#xF6E6 #xE0A3) (#xF6E5 #xE0A2) (#xF6E4 #xE0A1) (#xF6E3 #xE0A0) (#xF6E2 #xE09F) (#xF6E1 #xE09E) (#xF6E0 #xE09D) (#xF6DF #xE09C) (#xF6DE #xE09B) (#xF6DD #xE09A) (#xF6DC #xE099) (#xF6DB #xE098) (#xF6DA #xE097) (#xF6D9 #xE096) (#xF6D8 #xE095) (#xF6D7 #xE094) (#xF6D6 #xE093) (#xF6D5 #xE092) (#xF6D4 #xE091) (#xF6D3 #xE090) (#xF6D2 #xE08F) (#xF6D1 #xE08E) (#xF6D0 #xE08D) (#xF6CF #xE08C) (#xF6CE #xE08B) (#xF6CD #xE08A) (#xF6CC #xE089) (#xF6CB #xE088) (#xF6CA #xE087) (#xF6C9 #xE086) (#xF6C8 #xE085) (#xF6C7 #xE084) (#xF6C6 #xE083) (#xF6C5 #xE082) (#xF6C4 #xE081) (#xF6C3 #xE080) (#xF6C2 #xE07F) (#xF6C1 #xE07E) (#xF6C0 #xE07D) (#xF6BF #xE07C) (#xF6BE #xE07B) (#xF6BD #xE07A) (#xF6BC #xE079) (#xF6BB #xE078) (#xF6BA #xE077) (#xF6B9 #xE076) (#xF6B8 #xE075) (#xF6B7 #xE074) (#xF6B6 #xE073) (#xF6B5 #xE072) (#xF6B4 #xE071) (#xF6B3 #xE070) (#xF6B2 #xE06F) (#xF6B1 #xE06E) (#xF6B0 #xE06D) (#xF6AF #xE06C) (#xF6AE #xE06B) (#xF6AD #xE06A) (#xF6AC #xE069) (#xF6AB #xE068) (#xF6AA #xE067) (#xF6A9 #xE066) (#xF6A8 #xE065) (#xF6A7 #xE064) (#xF6A6 #xE063) (#xF6A5 #xE062) (#xF6A4 #xE061) (#xF6A3 #xE060) (#xF6A2 #xE05F) (#xF6A1 #xE05E) (#xF5FE #xE05D) (#xF5FD #xE05C) (#xF5FC #xE05B) (#xF5FB #xE05A) (#xF5FA #xE059) (#xF5F9 #xE058) (#xF5F8 #xE057) (#xF5F7 #xE056) (#xF5F6 #xE055) (#xF5F5 #xE054) (#xF5F4 #xE053) (#xF5F3 #xE052) (#xF5F2 #xE051) (#xF5F1 #xE050) (#xF5F0 #xE04F) (#xF5EF #xE04E) (#xF5EE #xE04D) (#xF5ED #xE04C) (#xF5EC #xE04B) (#xF5EB #xE04A) (#xF5EA #xE049) (#xF5E9 #xE048) (#xF5E8 #xE047) (#xF5E7 #xE046) (#xF5E6 #xE045) (#xF5E5 #xE044) (#xF5E4 #xE043) (#xF5E3 #xE042) (#xF5E2 #xE041) (#xF5E1 #xE040) (#xF5E0 #xE03F) (#xF5DF #xE03E) (#xF5DE #xE03D) (#xF5DD #xE03C) (#xF5DC #xE03B) (#xF5DB #xE03A) (#xF5DA #xE039) (#xF5D9 #xE038) (#xF5D8 #xE037) (#xF5D7 #xE036) (#xF5D6 #xE035) (#xF5D5 #xE034) (#xF5D4 #xE033) (#xF5D3 #xE032) (#xF5D2 #xE031) (#xF5D1 #xE030) (#xF5D0 #xE02F) (#xF5CF #xE02E) (#xF5CE #xE02D) (#xF5CD #xE02C) (#xF5CC #xE02B) (#xF5CB #xE02A) (#xF5CA #xE029) (#xF5C9 #xE028) (#xF5C8 #xE027) (#xF5C7 #xE026) (#xF5C6 #xE025) (#xF5C5 #xE024) (#xF5C4 #xE023) (#xF5C3 #xE022) (#xF5C2 #xE021) (#xF5C1 #xE020) (#xF5C0 #xE01F) (#xF5BF #xE01E) (#xF5BE #xE01D) (#xF5BD #xE01C) (#xF5BC #xE01B) (#xF5BB #xE01A) (#xF5BA #xE019) (#xF5B9 #xE018) (#xF5B8 #xE017) (#xF5B7 #xE016) (#xF5B6 #xE015) (#xF5B5 #xE014) (#xF5B4 #xE013) (#xF5B3 #xE012) (#xF5B2 #xE011) (#xF5B1 #xE010) (#xF5B0 #xE00F) (#xF5AF #xE00E) (#xF5AE #xE00D) (#xF5AD #xE00C) (#xF5AC #xE00B) (#xF5AB #xE00A) (#xF5AA #xE009) (#xF5A9 #xE008) (#xF5A8 #xE007) (#xF5A7 #xE006) (#xF5A6 #xE005) (#xF5A5 #xE004) (#xF5A4 #xE003) (#xF5A3 #xE002) (#xF5A2 #xE001) (#xF5A1 #xE000) )) (defvar *eucjp* '((#x8FA2AF #x2D8) (#x8FA2B0 #x2C7) (#x8FA2B1 #xB8) (#x8FA2B2 #x2D9) (#x8FA2B3 #x2DD) (#x8FA2B4 #xAF) (#x8FA2B5 #x2DB) (#x8FA2B6 #x2DA) (#x8FA2B7 #xFF5E) (#x8FA2B8 #x384) (#x8FA2B9 #x385) (#x8FA2C2 #xA1) (#x8FA2C3 #xA6) (#x8FA2C4 #xBF) (#x8FA2EB #xBA) (#x8FA2EC #xAA) (#x8FA2ED #xA9) (#x8FA2EE #xAE) (#x8FA2EF #x2122) (#x8FA2F0 #xA4) (#x8FA2F1 #x2116) (#x8FA6E1 #x386) (#x8FA6E2 #x388) (#x8FA6E3 #x389) (#x8FA6E4 #x38A) (#x8FA6E5 #x3AA) (#x8FA6E7 #x38C) (#x8FA6E9 #x38E) (#x8FA6EA #x3AB) (#x8FA6EC #x38F) (#x8FA6F1 #x3AC) (#x8FA6F2 #x3AD) (#x8FA6F3 #x3AE) (#x8FA6F4 #x3AF) (#x8FA6F5 #x3CA) (#x8FA6F6 #x390) (#x8FA6F7 #x3CC) (#x8FA6F8 #x3C2) (#x8FA6F9 #x3CD) (#x8FA6FA #x3CB) (#x8FA6FB #x3B0) (#x8FA6FC #x3CE) (#x8FA7C2 #x402) (#x8FA7C3 #x403) (#x8FA7C4 #x404) (#x8FA7C5 #x405) (#x8FA7C6 #x406) (#x8FA7C7 #x407) (#x8FA7C8 #x408) (#x8FA7C9 #x409) (#x8FA7CA #x40A) (#x8FA7CB #x40B) (#x8FA7CC #x40C) (#x8FA7CD #x40E) (#x8FA7CE #x40F) (#x8FA7F2 #x452) (#x8FA7F3 #x453) (#x8FA7F4 #x454) (#x8FA7F5 #x455) (#x8FA7F6 #x456) (#x8FA7F7 #x457) (#x8FA7F8 #x458) (#x8FA7F9 #x459) (#x8FA7FA #x45A) (#x8FA7FB #x45B) (#x8FA7FC #x45C) (#x8FA7FD #x45E) (#x8FA7FE #x45F) (#x8FA9A1 #xC6) (#x8FA9A2 #x110) (#x8FA9A4 #x126) (#x8FA9A6 #x132) (#x8FA9A8 #x141) (#x8FA9A9 #x13F) (#x8FA9AB #x14A) (#x8FA9AC #xD8) (#x8FA9AD #x152) (#x8FA9AF #x166) (#x8FA9B0 #xDE) (#x8FA9C1 #xE6) (#x8FA9C2 #x111) (#x8FA9C3 #xF0) (#x8FA9C4 #x127) (#x8FA9C5 #x131) (#x8FA9C6 #x133) (#x8FA9C7 #x138) (#x8FA9C8 #x142) (#x8FA9C9 #x140) (#x8FA9CA #x149) (#x8FA9CB #x14B) (#x8FA9CC #xF8) (#x8FA9CD #x153) (#x8FA9CE #xDF) (#x8FA9CF #x167) (#x8FA9D0 #xFE) (#x8FAAA1 #xC1) (#x8FAAA2 #xC0) (#x8FAAA3 #xC4) (#x8FAAA4 #xC2) (#x8FAAA5 #x102) (#x8FAAA6 #x1CD) (#x8FAAA7 #x100) (#x8FAAA8 #x104) (#x8FAAA9 #xC5) (#x8FAAAA #xC3) (#x8FAAAB #x106) (#x8FAAAC #x108) (#x8FAAAD #x10C) (#x8FAAAE #xC7) (#x8FAAAF #x10A) (#x8FAAB0 #x10E) (#x8FAAB1 #xC9) (#x8FAAB2 #xC8) (#x8FAAB3 #xCB) (#x8FAAB4 #xCA) (#x8FAAB5 #x11A) (#x8FAAB6 #x116) (#x8FAAB7 #x112) (#x8FAAB8 #x118) (#x8FAABA #x11C) (#x8FAABB #x11E) (#x8FAABC #x122) (#x8FAABD #x120) (#x8FAABE #x124) (#x8FAABF #xCD) (#x8FAAC0 #xCC) (#x8FAAC1 #xCF) (#x8FAAC2 #xCE) (#x8FAAC3 #x1CF) (#x8FAAC4 #x130) (#x8FAAC5 #x12A) (#x8FAAC6 #x12E) (#x8FAAC7 #x128) (#x8FAAC8 #x134) (#x8FAAC9 #x136) (#x8FAACA #x139) (#x8FAACB #x13D) (#x8FAACC #x13B) (#x8FAACD #x143) (#x8FAACE #x147) (#x8FAACF #x145) (#x8FAAD0 #xD1) (#x8FAAD1 #xD3) (#x8FAAD2 #xD2) (#x8FAAD3 #xD6) (#x8FAAD4 #xD4) (#x8FAAD5 #x1D1) (#x8FAAD6 #x150) (#x8FAAD7 #x14C) (#x8FAAD8 #xD5) (#x8FAAD9 #x154) (#x8FAADA #x158) (#x8FAADB #x156) (#x8FAADC #x15A) (#x8FAADD #x15C) (#x8FAADE #x160) (#x8FAADF #x15E) (#x8FAAE0 #x164) (#x8FAAE1 #x162) (#x8FAAE2 #xDA) (#x8FAAE3 #xD9) (#x8FAAE4 #xDC) (#x8FAAE5 #xDB) (#x8FAAE6 #x16C) (#x8FAAE7 #x1D3) (#x8FAAE8 #x170) (#x8FAAE9 #x16A) (#x8FAAEA #x172) (#x8FAAEB #x16E) (#x8FAAEC #x168) (#x8FAAED #x1D7) (#x8FAAEE #x1DB) (#x8FAAEF #x1D9) (#x8FAAF0 #x1D5) (#x8FAAF1 #x174) (#x8FAAF2 #xDD) (#x8FAAF3 #x178) (#x8FAAF4 #x176) (#x8FAAF5 #x179) (#x8FAAF6 #x17D) (#x8FAAF7 #x17B) (#x8FABA1 #xE1) (#x8FABA2 #xE0) (#x8FABA3 #xE4) (#x8FABA4 #xE2) (#x8FABA5 #x103) (#x8FABA6 #x1CE) (#x8FABA7 #x101) (#x8FABA8 #x105) (#x8FABA9 #xE5) (#x8FABAA #xE3) (#x8FABAB #x107) (#x8FABAC #x109) (#x8FABAD #x10D) (#x8FABAE #xE7) (#x8FABAF #x10B) (#x8FABB0 #x10F) (#x8FABB1 #xE9) (#x8FABB2 #xE8) (#x8FABB3 #xEB) (#x8FABB4 #xEA) (#x8FABB5 #x11B) (#x8FABB6 #x117) (#x8FABB7 #x113) (#x8FABB8 #x119) (#x8FABB9 #x1F5) (#x8FABBA #x11D) (#x8FABBB #x11F) (#x8FABBD #x121) (#x8FABBE #x125) (#x8FABBF #xED) (#x8FABC0 #xEC) (#x8FABC1 #xEF) (#x8FABC2 #xEE) (#x8FABC3 #x1D0) (#x8FABC5 #x12B) (#x8FABC6 #x12F) (#x8FABC7 #x129) (#x8FABC8 #x135) (#x8FABC9 #x137) (#x8FABCA #x13A) (#x8FABCB #x13E) (#x8FABCC #x13C) (#x8FABCD #x144) (#x8FABCE #x148) (#x8FABCF #x146) (#x8FABD0 #xF1) (#x8FABD1 #xF3) (#x8FABD2 #xF2) (#x8FABD3 #xF6) (#x8FABD4 #xF4) (#x8FABD5 #x1D2) (#x8FABD6 #x151) (#x8FABD7 #x14D) (#x8FABD8 #xF5) (#x8FABD9 #x155) (#x8FABDA #x159) (#x8FABDB #x157) (#x8FABDC #x15B) (#x8FABDD #x15D) (#x8FABDE #x161) (#x8FABDF #x15F) (#x8FABE0 #x165) (#x8FABE1 #x163) (#x8FABE2 #xFA) (#x8FABE3 #xF9) (#x8FABE4 #xFC) (#x8FABE5 #xFB) (#x8FABE6 #x16D) (#x8FABE7 #x1D4) (#x8FABE8 #x171) (#x8FABE9 #x16B) (#x8FABEA #x173) (#x8FABEB #x16F) (#x8FABEC #x169) (#x8FABED #x1D8) (#x8FABEE #x1DC) (#x8FABEF #x1DA) (#x8FABF0 #x1D6) (#x8FABF1 #x175) (#x8FABF2 #xFD) (#x8FABF3 #xFF) (#x8FABF4 #x177) (#x8FABF5 #x17A) (#x8FABF6 #x17E) (#x8FABF7 #x17C) (#x8FB0A1 #x4E02) (#x8FB0A2 #x4E04) (#x8FB0A3 #x4E05) (#x8FB0A4 #x4E0C) (#x8FB0A5 #x4E12) (#x8FB0A6 #x4E1F) (#x8FB0A7 #x4E23) (#x8FB0A8 #x4E24) (#x8FB0A9 #x4E28) (#x8FB0AA #x4E2B) (#x8FB0AB #x4E2E) (#x8FB0AC #x4E2F) (#x8FB0AD #x4E30) (#x8FB0AE #x4E35) (#x8FB0AF #x4E40) (#x8FB0B0 #x4E41) (#x8FB0B1 #x4E44) (#x8FB0B2 #x4E47) (#x8FB0B3 #x4E51) (#x8FB0B4 #x4E5A) (#x8FB0B5 #x4E5C) (#x8FB0B6 #x4E63) (#x8FB0B7 #x4E68) (#x8FB0B8 #x4E69) (#x8FB0B9 #x4E74) (#x8FB0BA #x4E75) (#x8FB0BB #x4E79) (#x8FB0BC #x4E7F) (#x8FB0BD #x4E8D) (#x8FB0BE #x4E96) (#x8FB0BF #x4E97) (#x8FB0C0 #x4E9D) (#x8FB0C1 #x4EAF) (#x8FB0C2 #x4EB9) (#x8FB0C3 #x4EC3) (#x8FB0C4 #x4ED0) (#x8FB0C5 #x4EDA) (#x8FB0C6 #x4EDB) (#x8FB0C7 #x4EE0) (#x8FB0C8 #x4EE1) (#x8FB0C9 #x4EE2) (#x8FB0CA #x4EE8) (#x8FB0CB #x4EEF) (#x8FB0CC #x4EF1) (#x8FB0CD #x4EF3) (#x8FB0CE #x4EF5) (#x8FB0CF #x4EFD) (#x8FB0D0 #x4EFE) (#x8FB0D1 #x4EFF) (#x8FB0D2 #x4F00) (#x8FB0D3 #x4F02) (#x8FB0D4 #x4F03) (#x8FB0D5 #x4F08) (#x8FB0D6 #x4F0B) (#x8FB0D7 #x4F0C) (#x8FB0D8 #x4F12) (#x8FB0D9 #x4F15) (#x8FB0DA #x4F16) (#x8FB0DB #x4F17) (#x8FB0DC #x4F19) (#x8FB0DD #x4F2E) (#x8FB0DE #x4F31) (#x8FB0DF #x4F60) (#x8FB0E0 #x4F33) (#x8FB0E1 #x4F35) (#x8FB0E2 #x4F37) (#x8FB0E3 #x4F39) (#x8FB0E4 #x4F3B) (#x8FB0E5 #x4F3E) (#x8FB0E6 #x4F40) (#x8FB0E7 #x4F42) (#x8FB0E8 #x4F48) (#x8FB0E9 #x4F49) (#x8FB0EA #x4F4B) (#x8FB0EB #x4F4C) (#x8FB0EC #x4F52) (#x8FB0ED #x4F54) (#x8FB0EE #x4F56) (#x8FB0EF #x4F58) (#x8FB0F0 #x4F5F) (#x8FB0F1 #x4F63) (#x8FB0F2 #x4F6A) (#x8FB0F3 #x4F6C) (#x8FB0F4 #x4F6E) (#x8FB0F5 #x4F71) (#x8FB0F6 #x4F77) (#x8FB0F7 #x4F78) (#x8FB0F8 #x4F79) (#x8FB0F9 #x4F7A) (#x8FB0FA #x4F7D) (#x8FB0FB #x4F7E) (#x8FB0FC #x4F81) (#x8FB0FD #x4F82) (#x8FB0FE #x4F84) (#x8FB1A1 #x4F85) (#x8FB1A2 #x4F89) (#x8FB1A3 #x4F8A) (#x8FB1A4 #x4F8C) (#x8FB1A5 #x4F8E) (#x8FB1A6 #x4F90) (#x8FB1A7 #x4F92) (#x8FB1A8 #x4F93) (#x8FB1A9 #x4F94) (#x8FB1AA #x4F97) (#x8FB1AB #x4F99) (#x8FB1AC #x4F9A) (#x8FB1AD #x4F9E) (#x8FB1AE #x4F9F) (#x8FB1AF #x4FB2) (#x8FB1B0 #x4FB7) (#x8FB1B1 #x4FB9) (#x8FB1B2 #x4FBB) (#x8FB1B3 #x4FBC) (#x8FB1B4 #x4FBD) (#x8FB1B5 #x4FBE) (#x8FB1B6 #x4FC0) (#x8FB1B7 #x4FC1) (#x8FB1B8 #x4FC5) (#x8FB1B9 #x4FC6) (#x8FB1BA #x4FC8) (#x8FB1BB #x4FC9) (#x8FB1BC #x4FCB) (#x8FB1BD #x4FCC) (#x8FB1BE #x4FCD) (#x8FB1BF #x4FCF) (#x8FB1C0 #x4FD2) (#x8FB1C1 #x4FDC) (#x8FB1C2 #x4FE0) (#x8FB1C3 #x4FE2) (#x8FB1C4 #x4FF0) (#x8FB1C5 #x4FF2) (#x8FB1C6 #x4FFC) (#x8FB1C7 #x4FFD) (#x8FB1C8 #x4FFF) (#x8FB1C9 #x5000) (#x8FB1CA #x5001) (#x8FB1CB #x5004) (#x8FB1CC #x5007) (#x8FB1CD #x500A) (#x8FB1CE #x500C) (#x8FB1CF #x500E) (#x8FB1D0 #x5010) (#x8FB1D1 #x5013) (#x8FB1D2 #x5017) (#x8FB1D3 #x5018) (#x8FB1D4 #x501B) (#x8FB1D5 #x501C) (#x8FB1D6 #x501D) (#x8FB1D7 #x501E) (#x8FB1D8 #x5022) (#x8FB1D9 #x5027) (#x8FB1DA #x502E) (#x8FB1DB #x5030) (#x8FB1DC #x5032) (#x8FB1DD #x5033) (#x8FB1DE #x5035) (#x8FB1DF #x5040) (#x8FB1E0 #x5041) (#x8FB1E1 #x5042) (#x8FB1E2 #x5045) (#x8FB1E3 #x5046) (#x8FB1E4 #x504A) (#x8FB1E5 #x504C) (#x8FB1E6 #x504E) (#x8FB1E7 #x5051) (#x8FB1E8 #x5052) (#x8FB1E9 #x5053) (#x8FB1EA #x5057) (#x8FB1EB #x5059) (#x8FB1EC #x505F) (#x8FB1ED #x5060) (#x8FB1EE #x5062) (#x8FB1EF #x5063) (#x8FB1F0 #x5066) (#x8FB1F1 #x5067) (#x8FB1F2 #x506A) (#x8FB1F3 #x506D) (#x8FB1F4 #x5070) (#x8FB1F5 #x5071) (#x8FB1F6 #x503B) (#x8FB1F7 #x5081) (#x8FB1F8 #x5083) (#x8FB1F9 #x5084) (#x8FB1FA #x5086) (#x8FB1FB #x508A) (#x8FB1FC #x508E) (#x8FB1FD #x508F) (#x8FB1FE #x5090) (#x8FB2A1 #x5092) (#x8FB2A2 #x5093) (#x8FB2A3 #x5094) (#x8FB2A4 #x5096) (#x8FB2A5 #x509B) (#x8FB2A6 #x509C) (#x8FB2A7 #x509E) (#x8FB2A8 #x509F) (#x8FB2A9 #x50A0) (#x8FB2AA #x50A1) (#x8FB2AB #x50A2) (#x8FB2AC #x50AA) (#x8FB2AD #x50AF) (#x8FB2AE #x50B0) (#x8FB2AF #x50B9) (#x8FB2B0 #x50BA) (#x8FB2B1 #x50BD) (#x8FB2B2 #x50C0) (#x8FB2B3 #x50C3) (#x8FB2B4 #x50C4) (#x8FB2B5 #x50C7) (#x8FB2B6 #x50CC) (#x8FB2B7 #x50CE) (#x8FB2B8 #x50D0) (#x8FB2B9 #x50D3) (#x8FB2BA #x50D4) (#x8FB2BB #x50D8) (#x8FB2BC #x50DC) (#x8FB2BD #x50DD) (#x8FB2BE #x50DF) (#x8FB2BF #x50E2) (#x8FB2C0 #x50E4) (#x8FB2C1 #x50E6) (#x8FB2C2 #x50E8) (#x8FB2C3 #x50E9) (#x8FB2C4 #x50EF) (#x8FB2C5 #x50F1) (#x8FB2C6 #x50F6) (#x8FB2C7 #x50FA) (#x8FB2C8 #x50FE) (#x8FB2C9 #x5103) (#x8FB2CA #x5106) (#x8FB2CB #x5107) (#x8FB2CC #x5108) (#x8FB2CD #x510B) (#x8FB2CE #x510C) (#x8FB2CF #x510D) (#x8FB2D0 #x510E) (#x8FB2D1 #x50F2) (#x8FB2D2 #x5110) (#x8FB2D3 #x5117) (#x8FB2D4 #x5119) (#x8FB2D5 #x511B) (#x8FB2D6 #x511C) (#x8FB2D7 #x511D) (#x8FB2D8 #x511E) (#x8FB2D9 #x5123) (#x8FB2DA #x5127) (#x8FB2DB #x5128) (#x8FB2DC #x512C) (#x8FB2DD #x512D) (#x8FB2DE #x512F) (#x8FB2DF #x5131) (#x8FB2E0 #x5133) (#x8FB2E1 #x5134) (#x8FB2E2 #x5135) (#x8FB2E3 #x5138) (#x8FB2E4 #x5139) (#x8FB2E5 #x5142) (#x8FB2E6 #x514A) (#x8FB2E7 #x514F) (#x8FB2E8 #x5153) (#x8FB2E9 #x5155) (#x8FB2EA #x5157) (#x8FB2EB #x5158) (#x8FB2EC #x515F) (#x8FB2ED #x5164) (#x8FB2EE #x5166) (#x8FB2EF #x517E) (#x8FB2F0 #x5183) (#x8FB2F1 #x5184) (#x8FB2F2 #x518B) (#x8FB2F3 #x518E) (#x8FB2F4 #x5198) (#x8FB2F5 #x519D) (#x8FB2F6 #x51A1) (#x8FB2F7 #x51A3) (#x8FB2F8 #x51AD) (#x8FB2F9 #x51B8) (#x8FB2FA #x51BA) (#x8FB2FB #x51BC) (#x8FB2FC #x51BE) (#x8FB2FD #x51BF) (#x8FB2FE #x51C2) (#x8FB3A1 #x51C8) (#x8FB3A2 #x51CF) (#x8FB3A3 #x51D1) (#x8FB3A4 #x51D2) (#x8FB3A5 #x51D3) (#x8FB3A6 #x51D5) (#x8FB3A7 #x51D8) (#x8FB3A8 #x51DE) (#x8FB3A9 #x51E2) (#x8FB3AA #x51E5) (#x8FB3AB #x51EE) (#x8FB3AC #x51F2) (#x8FB3AD #x51F3) (#x8FB3AE #x51F4) (#x8FB3AF #x51F7) (#x8FB3B0 #x5201) (#x8FB3B1 #x5202) (#x8FB3B2 #x5205) (#x8FB3B3 #x5212) (#x8FB3B4 #x5213) (#x8FB3B5 #x5215) (#x8FB3B6 #x5216) (#x8FB3B7 #x5218) (#x8FB3B8 #x5222) (#x8FB3B9 #x5228) (#x8FB3BA #x5231) (#x8FB3BB #x5232) (#x8FB3BC #x5235) (#x8FB3BD #x523C) (#x8FB3BE #x5245) (#x8FB3BF #x5249) (#x8FB3C0 #x5255) (#x8FB3C1 #x5257) (#x8FB3C2 #x5258) (#x8FB3C3 #x525A) (#x8FB3C4 #x525C) (#x8FB3C5 #x525F) (#x8FB3C6 #x5260) (#x8FB3C7 #x5261) (#x8FB3C8 #x5266) (#x8FB3C9 #x526E) (#x8FB3CA #x5277) (#x8FB3CB #x5278) (#x8FB3CC #x5279) (#x8FB3CD #x5280) (#x8FB3CE #x5282) (#x8FB3CF #x5285) (#x8FB3D0 #x528A) (#x8FB3D1 #x528C) (#x8FB3D2 #x5293) (#x8FB3D3 #x5295) (#x8FB3D4 #x5296) (#x8FB3D5 #x5297) (#x8FB3D6 #x5298) (#x8FB3D7 #x529A) (#x8FB3D8 #x529C) (#x8FB3D9 #x52A4) (#x8FB3DA #x52A5) (#x8FB3DB #x52A6) (#x8FB3DC #x52A7) (#x8FB3DD #x52AF) (#x8FB3DE #x52B0) (#x8FB3DF #x52B6) (#x8FB3E0 #x52B7) (#x8FB3E1 #x52B8) (#x8FB3E2 #x52BA) (#x8FB3E3 #x52BB) (#x8FB3E4 #x52BD) (#x8FB3E5 #x52C0) (#x8FB3E6 #x52C4) (#x8FB3E7 #x52C6) (#x8FB3E8 #x52C8) (#x8FB3E9 #x52CC) (#x8FB3EA #x52CF) (#x8FB3EB #x52D1) (#x8FB3EC #x52D4) (#x8FB3ED #x52D6) (#x8FB3EE #x52DB) (#x8FB3EF #x52DC) (#x8FB3F0 #x52E1) (#x8FB3F1 #x52E5) (#x8FB3F2 #x52E8) (#x8FB3F3 #x52E9) (#x8FB3F4 #x52EA) (#x8FB3F5 #x52EC) (#x8FB3F6 #x52F0) (#x8FB3F7 #x52F1) (#x8FB3F8 #x52F4) (#x8FB3F9 #x52F6) (#x8FB3FA #x52F7) (#x8FB3FB #x5300) (#x8FB3FC #x5303) (#x8FB3FD #x530A) (#x8FB3FE #x530B) (#x8FB4A1 #x530C) (#x8FB4A2 #x5311) (#x8FB4A3 #x5313) (#x8FB4A4 #x5318) (#x8FB4A5 #x531B) (#x8FB4A6 #x531C) (#x8FB4A7 #x531E) (#x8FB4A8 #x531F) (#x8FB4A9 #x5325) (#x8FB4AA #x5327) (#x8FB4AB #x5328) (#x8FB4AC #x5329) (#x8FB4AD #x532B) (#x8FB4AE #x532C) (#x8FB4AF #x532D) (#x8FB4B0 #x5330) (#x8FB4B1 #x5332) (#x8FB4B2 #x5335) (#x8FB4B3 #x533C) (#x8FB4B4 #x533D) (#x8FB4B5 #x533E) (#x8FB4B6 #x5342) (#x8FB4B7 #x534C) (#x8FB4B8 #x534B) (#x8FB4B9 #x5359) (#x8FB4BA #x535B) (#x8FB4BB #x5361) (#x8FB4BC #x5363) (#x8FB4BD #x5365) (#x8FB4BE #x536C) (#x8FB4BF #x536D) (#x8FB4C0 #x5372) (#x8FB4C1 #x5379) (#x8FB4C2 #x537E) (#x8FB4C3 #x5383) (#x8FB4C4 #x5387) (#x8FB4C5 #x5388) (#x8FB4C6 #x538E) (#x8FB4C7 #x5393) (#x8FB4C8 #x5394) (#x8FB4C9 #x5399) (#x8FB4CA #x539D) (#x8FB4CB #x53A1) (#x8FB4CC #x53A4) (#x8FB4CD #x53AA) (#x8FB4CE #x53AB) (#x8FB4CF #x53AF) (#x8FB4D0 #x53B2) (#x8FB4D1 #x53B4) (#x8FB4D2 #x53B5) (#x8FB4D3 #x53B7) (#x8FB4D4 #x53B8) (#x8FB4D5 #x53BA) (#x8FB4D6 #x53BD) (#x8FB4D7 #x53C0) (#x8FB4D8 #x53C5) (#x8FB4D9 #x53CF) (#x8FB4DA #x53D2) (#x8FB4DB #x53D3) (#x8FB4DC #x53D5) (#x8FB4DD #x53DA) (#x8FB4DE #x53DD) (#x8FB4DF #x53DE) (#x8FB4E0 #x53E0) (#x8FB4E1 #x53E6) (#x8FB4E2 #x53E7) (#x8FB4E3 #x53F5) (#x8FB4E4 #x5402) (#x8FB4E5 #x5413) (#x8FB4E6 #x541A) (#x8FB4E7 #x5421) (#x8FB4E8 #x5427) (#x8FB4E9 #x5428) (#x8FB4EA #x542A) (#x8FB4EB #x542F) (#x8FB4EC #x5431) (#x8FB4ED #x5434) (#x8FB4EE #x5435) (#x8FB4EF #x5443) (#x8FB4F0 #x5444) (#x8FB4F1 #x5447) (#x8FB4F2 #x544D) (#x8FB4F3 #x544F) (#x8FB4F4 #x545E) (#x8FB4F5 #x5462) (#x8FB4F6 #x5464) (#x8FB4F7 #x5466) (#x8FB4F8 #x5467) (#x8FB4F9 #x5469) (#x8FB4FA #x546B) (#x8FB4FB #x546D) (#x8FB4FC #x546E) (#x8FB4FD #x5474) (#x8FB4FE #x547F) (#x8FB5A1 #x5481) (#x8FB5A2 #x5483) (#x8FB5A3 #x5485) (#x8FB5A4 #x5488) (#x8FB5A5 #x5489) (#x8FB5A6 #x548D) (#x8FB5A7 #x5491) (#x8FB5A8 #x5495) (#x8FB5A9 #x5496) (#x8FB5AA #x549C) (#x8FB5AB #x549F) (#x8FB5AC #x54A1) (#x8FB5AD #x54A6) (#x8FB5AE #x54A7) (#x8FB5AF #x54A9) (#x8FB5B0 #x54AA) (#x8FB5B1 #x54AD) (#x8FB5B2 #x54AE) (#x8FB5B3 #x54B1) (#x8FB5B4 #x54B7) (#x8FB5B5 #x54B9) (#x8FB5B6 #x54BA) (#x8FB5B7 #x54BB) (#x8FB5B8 #x54BF) (#x8FB5B9 #x54C6) (#x8FB5BA #x54CA) (#x8FB5BB #x54CD) (#x8FB5BC #x54CE) (#x8FB5BD #x54E0) (#x8FB5BE #x54EA) (#x8FB5BF #x54EC) (#x8FB5C0 #x54EF) (#x8FB5C1 #x54F6) (#x8FB5C2 #x54FC) (#x8FB5C3 #x54FE) (#x8FB5C4 #x54FF) (#x8FB5C5 #x5500) (#x8FB5C6 #x5501) (#x8FB5C7 #x5505) (#x8FB5C8 #x5508) (#x8FB5C9 #x5509) (#x8FB5CA #x550C) (#x8FB5CB #x550D) (#x8FB5CC #x550E) (#x8FB5CD #x5515) (#x8FB5CE #x552A) (#x8FB5CF #x552B) (#x8FB5D0 #x5532) (#x8FB5D1 #x5535) (#x8FB5D2 #x5536) (#x8FB5D3 #x553B) (#x8FB5D4 #x553C) (#x8FB5D5 #x553D) (#x8FB5D6 #x5541) (#x8FB5D7 #x5547) (#x8FB5D8 #x5549) (#x8FB5D9 #x554A) (#x8FB5DA #x554D) (#x8FB5DB #x5550) (#x8FB5DC #x5551) (#x8FB5DD #x5558) (#x8FB5DE #x555A) (#x8FB5DF #x555B) (#x8FB5E0 #x555E) (#x8FB5E1 #x5560) (#x8FB5E2 #x5561) (#x8FB5E3 #x5564) (#x8FB5E4 #x5566) (#x8FB5E5 #x557F) (#x8FB5E6 #x5581) (#x8FB5E7 #x5582) (#x8FB5E8 #x5586) (#x8FB5E9 #x5588) (#x8FB5EA #x558E) (#x8FB5EB #x558F) (#x8FB5EC #x5591) (#x8FB5ED #x5592) (#x8FB5EE #x5593) (#x8FB5EF #x5594) (#x8FB5F0 #x5597) (#x8FB5F1 #x55A3) (#x8FB5F2 #x55A4) (#x8FB5F3 #x55AD) (#x8FB5F4 #x55B2) (#x8FB5F5 #x55BF) (#x8FB5F6 #x55C1) (#x8FB5F7 #x55C3) (#x8FB5F8 #x55C6) (#x8FB5F9 #x55C9) (#x8FB5FA #x55CB) (#x8FB5FB #x55CC) (#x8FB5FC #x55CE) (#x8FB5FD #x55D1) (#x8FB5FE #x55D2) (#x8FB6A1 #x55D3) (#x8FB6A2 #x55D7) (#x8FB6A3 #x55D8) (#x8FB6A4 #x55DB) (#x8FB6A5 #x55DE) (#x8FB6A6 #x55E2) (#x8FB6A7 #x55E9) (#x8FB6A8 #x55F6) (#x8FB6A9 #x55FF) (#x8FB6AA #x5605) (#x8FB6AB #x5608) (#x8FB6AC #x560A) (#x8FB6AD #x560D) (#x8FB6AE #x560E) (#x8FB6AF #x560F) (#x8FB6B0 #x5610) (#x8FB6B1 #x5611) (#x8FB6B2 #x5612) (#x8FB6B3 #x5619) (#x8FB6B4 #x562C) (#x8FB6B5 #x5630) (#x8FB6B6 #x5633) (#x8FB6B7 #x5635) (#x8FB6B8 #x5637) (#x8FB6B9 #x5639) (#x8FB6BA #x563B) (#x8FB6BB #x563C) (#x8FB6BC #x563D) (#x8FB6BD #x563F) (#x8FB6BE #x5640) (#x8FB6BF #x5641) (#x8FB6C0 #x5643) (#x8FB6C1 #x5644) (#x8FB6C2 #x5646) (#x8FB6C3 #x5649) (#x8FB6C4 #x564B) (#x8FB6C5 #x564D) (#x8FB6C6 #x564F) (#x8FB6C7 #x5654) (#x8FB6C8 #x565E) (#x8FB6C9 #x5660) (#x8FB6CA #x5661) (#x8FB6CB #x5662) (#x8FB6CC #x5663) (#x8FB6CD #x5666) (#x8FB6CE #x5669) (#x8FB6CF #x566D) (#x8FB6D0 #x566F) (#x8FB6D1 #x5671) (#x8FB6D2 #x5672) (#x8FB6D3 #x5675) (#x8FB6D4 #x5684) (#x8FB6D5 #x5685) (#x8FB6D6 #x5688) (#x8FB6D7 #x568B) (#x8FB6D8 #x568C) (#x8FB6D9 #x5695) (#x8FB6DA #x5699) (#x8FB6DB #x569A) (#x8FB6DC #x569D) (#x8FB6DD #x569E) (#x8FB6DE #x569F) (#x8FB6DF #x56A6) (#x8FB6E0 #x56A7) (#x8FB6E1 #x56A8) (#x8FB6E2 #x56A9) (#x8FB6E3 #x56AB) (#x8FB6E4 #x56AC) (#x8FB6E5 #x56AD) (#x8FB6E6 #x56B1) (#x8FB6E7 #x56B3) (#x8FB6E8 #x56B7) (#x8FB6E9 #x56BE) (#x8FB6EA #x56C5) (#x8FB6EB #x56C9) (#x8FB6EC #x56CA) (#x8FB6ED #x56CB) (#x8FB6EE #x56CF) (#x8FB6EF #x56D0) (#x8FB6F0 #x56CC) (#x8FB6F1 #x56CD) (#x8FB6F2 #x56D9) (#x8FB6F3 #x56DC) (#x8FB6F4 #x56DD) (#x8FB6F5 #x56DF) (#x8FB6F6 #x56E1) (#x8FB6F7 #x56E4) (#x8FB6F8 #x56E5) (#x8FB6F9 #x56E6) (#x8FB6FA #x56E7) (#x8FB6FB #x56E8) (#x8FB6FC #x56F1) (#x8FB6FD #x56EB) (#x8FB6FE #x56ED) (#x8FB7A1 #x56F6) (#x8FB7A2 #x56F7) (#x8FB7A3 #x5701) (#x8FB7A4 #x5702) (#x8FB7A5 #x5707) (#x8FB7A6 #x570A) (#x8FB7A7 #x570C) (#x8FB7A8 #x5711) (#x8FB7A9 #x5715) (#x8FB7AA #x571A) (#x8FB7AB #x571B) (#x8FB7AC #x571D) (#x8FB7AD #x5720) (#x8FB7AE #x5722) (#x8FB7AF #x5723) (#x8FB7B0 #x5724) (#x8FB7B1 #x5725) (#x8FB7B2 #x5729) (#x8FB7B3 #x572A) (#x8FB7B4 #x572C) (#x8FB7B5 #x572E) (#x8FB7B6 #x572F) (#x8FB7B7 #x5733) (#x8FB7B8 #x5734) (#x8FB7B9 #x573D) (#x8FB7BA #x573E) (#x8FB7BB #x573F) (#x8FB7BC #x5745) (#x8FB7BD #x5746) (#x8FB7BE #x574C) (#x8FB7BF #x574D) (#x8FB7C0 #x5752) (#x8FB7C1 #x5762) (#x8FB7C2 #x5765) (#x8FB7C3 #x5767) (#x8FB7C4 #x5768) (#x8FB7C5 #x576B) (#x8FB7C6 #x576D) (#x8FB7C7 #x576E) (#x8FB7C8 #x576F) (#x8FB7C9 #x5770) (#x8FB7CA #x5771) (#x8FB7CB #x5773) (#x8FB7CC #x5774) (#x8FB7CD #x5775) (#x8FB7CE #x5777) (#x8FB7CF #x5779) (#x8FB7D0 #x577A) (#x8FB7D1 #x577B) (#x8FB7D2 #x577C) (#x8FB7D3 #x577E) (#x8FB7D4 #x5781) (#x8FB7D5 #x5783) (#x8FB7D6 #x578C) (#x8FB7D7 #x5794) (#x8FB7D8 #x5797) (#x8FB7D9 #x5799) (#x8FB7DA #x579A) (#x8FB7DB #x579C) (#x8FB7DC #x579D) (#x8FB7DD #x579E) (#x8FB7DE #x579F) (#x8FB7DF #x57A1) (#x8FB7E0 #x5795) (#x8FB7E1 #x57A7) (#x8FB7E2 #x57A8) (#x8FB7E3 #x57A9) (#x8FB7E4 #x57AC) (#x8FB7E5 #x57B8) (#x8FB7E6 #x57BD) (#x8FB7E7 #x57C7) (#x8FB7E8 #x57C8) (#x8FB7E9 #x57CC) (#x8FB7EA #x57CF) (#x8FB7EB #x57D5) (#x8FB7EC #x57DD) (#x8FB7ED #x57DE) (#x8FB7EE #x57E4) (#x8FB7EF #x57E6) (#x8FB7F0 #x57E7) (#x8FB7F1 #x57E9) (#x8FB7F2 #x57ED) (#x8FB7F3 #x57F0) (#x8FB7F4 #x57F5) (#x8FB7F5 #x57F6) (#x8FB7F6 #x57F8) (#x8FB7F7 #x57FD) (#x8FB7F8 #x57FE) (#x8FB7F9 #x57FF) (#x8FB7FA #x5803) (#x8FB7FB #x5804) (#x8FB7FC #x5808) (#x8FB7FD #x5809) (#x8FB7FE #x57E1) (#x8FB8A1 #x580C) (#x8FB8A2 #x580D) (#x8FB8A3 #x581B) (#x8FB8A4 #x581E) (#x8FB8A5 #x581F) (#x8FB8A6 #x5820) (#x8FB8A7 #x5826) (#x8FB8A8 #x5827) (#x8FB8A9 #x582D) (#x8FB8AA #x5832) (#x8FB8AB #x5839) (#x8FB8AC #x583F) (#x8FB8AD #x5849) (#x8FB8AE #x584C) (#x8FB8AF #x584D) (#x8FB8B0 #x584F) (#x8FB8B1 #x5850) (#x8FB8B2 #x5855) (#x8FB8B3 #x585F) (#x8FB8B4 #x5861) (#x8FB8B5 #x5864) (#x8FB8B6 #x5867) (#x8FB8B7 #x5868) (#x8FB8B8 #x5878) (#x8FB8B9 #x587C) (#x8FB8BA #x587F) (#x8FB8BB #x5880) (#x8FB8BC #x5881) (#x8FB8BD #x5887) (#x8FB8BE #x5888) (#x8FB8BF #x5889) (#x8FB8C0 #x588A) (#x8FB8C1 #x588C) (#x8FB8C2 #x588D) (#x8FB8C3 #x588F) (#x8FB8C4 #x5890) (#x8FB8C5 #x5894) (#x8FB8C6 #x5896) (#x8FB8C7 #x589D) (#x8FB8C8 #x58A0) (#x8FB8C9 #x58A1) (#x8FB8CA #x58A2) (#x8FB8CB #x58A6) (#x8FB8CC #x58A9) (#x8FB8CD #x58B1) (#x8FB8CE #x58B2) (#x8FB8CF #x58C4) (#x8FB8D0 #x58BC) (#x8FB8D1 #x58C2) (#x8FB8D2 #x58C8) (#x8FB8D3 #x58CD) (#x8FB8D4 #x58CE) (#x8FB8D5 #x58D0) (#x8FB8D6 #x58D2) (#x8FB8D7 #x58D4) (#x8FB8D8 #x58D6) (#x8FB8D9 #x58DA) (#x8FB8DA #x58DD) (#x8FB8DB #x58E1) (#x8FB8DC #x58E2) (#x8FB8DD #x58E9) (#x8FB8DE #x58F3) (#x8FB8DF #x5905) (#x8FB8E0 #x5906) (#x8FB8E1 #x590B) (#x8FB8E2 #x590C) (#x8FB8E3 #x5912) (#x8FB8E4 #x5913) (#x8FB8E5 #x5914) (#x8FB8E6 #x8641) (#x8FB8E7 #x591D) (#x8FB8E8 #x5921) (#x8FB8E9 #x5923) (#x8FB8EA #x5924) (#x8FB8EB #x5928) (#x8FB8EC #x592F) (#x8FB8ED #x5930) (#x8FB8EE #x5933) (#x8FB8EF #x5935) (#x8FB8F0 #x5936) (#x8FB8F1 #x593F) (#x8FB8F2 #x5943) (#x8FB8F3 #x5946) (#x8FB8F4 #x5952) (#x8FB8F5 #x5953) (#x8FB8F6 #x5959) (#x8FB8F7 #x595B) (#x8FB8F8 #x595D) (#x8FB8F9 #x595E) (#x8FB8FA #x595F) (#x8FB8FB #x5961) (#x8FB8FC #x5963) (#x8FB8FD #x596B) (#x8FB8FE #x596D) (#x8FB9A1 #x596F) (#x8FB9A2 #x5972) (#x8FB9A3 #x5975) (#x8FB9A4 #x5976) (#x8FB9A5 #x5979) (#x8FB9A6 #x597B) (#x8FB9A7 #x597C) (#x8FB9A8 #x598B) (#x8FB9A9 #x598C) (#x8FB9AA #x598E) (#x8FB9AB #x5992) (#x8FB9AC #x5995) (#x8FB9AD #x5997) (#x8FB9AE #x599F) (#x8FB9AF #x59A4) (#x8FB9B0 #x59A7) (#x8FB9B1 #x59AD) (#x8FB9B2 #x59AE) (#x8FB9B3 #x59AF) (#x8FB9B4 #x59B0) (#x8FB9B5 #x59B3) (#x8FB9B6 #x59B7) (#x8FB9B7 #x59BA) (#x8FB9B8 #x59BC) (#x8FB9B9 #x59C1) (#x8FB9BA #x59C3) (#x8FB9BB #x59C4) (#x8FB9BC #x59C8) (#x8FB9BD #x59CA) (#x8FB9BE #x59CD) (#x8FB9BF #x59D2) (#x8FB9C0 #x59DD) (#x8FB9C1 #x59DE) (#x8FB9C2 #x59DF) (#x8FB9C3 #x59E3) (#x8FB9C4 #x59E4) (#x8FB9C5 #x59E7) (#x8FB9C6 #x59EE) (#x8FB9C7 #x59EF) (#x8FB9C8 #x59F1) (#x8FB9C9 #x59F2) (#x8FB9CA #x59F4) (#x8FB9CB #x59F7) (#x8FB9CC #x5A00) (#x8FB9CD #x5A04) (#x8FB9CE #x5A0C) (#x8FB9CF #x5A0D) (#x8FB9D0 #x5A0E) (#x8FB9D1 #x5A12) (#x8FB9D2 #x5A13) (#x8FB9D3 #x5A1E) (#x8FB9D4 #x5A23) (#x8FB9D5 #x5A24) (#x8FB9D6 #x5A27) (#x8FB9D7 #x5A28) (#x8FB9D8 #x5A2A) (#x8FB9D9 #x5A2D) (#x8FB9DA #x5A30) (#x8FB9DB #x5A44) (#x8FB9DC #x5A45) (#x8FB9DD #x5A47) (#x8FB9DE #x5A48) (#x8FB9DF #x5A4C) (#x8FB9E0 #x5A50) (#x8FB9E1 #x5A55) (#x8FB9E2 #x5A5E) (#x8FB9E3 #x5A63) (#x8FB9E4 #x5A65) (#x8FB9E5 #x5A67) (#x8FB9E6 #x5A6D) (#x8FB9E7 #x5A77) (#x8FB9E8 #x5A7A) (#x8FB9E9 #x5A7B) (#x8FB9EA #x5A7E) (#x8FB9EB #x5A8B) (#x8FB9EC #x5A90) (#x8FB9ED #x5A93) (#x8FB9EE #x5A96) (#x8FB9EF #x5A99) (#x8FB9F0 #x5A9C) (#x8FB9F1 #x5A9E) (#x8FB9F2 #x5A9F) (#x8FB9F3 #x5AA0) (#x8FB9F4 #x5AA2) (#x8FB9F5 #x5AA7) (#x8FB9F6 #x5AAC) (#x8FB9F7 #x5AB1) (#x8FB9F8 #x5AB2) (#x8FB9F9 #x5AB3) (#x8FB9FA #x5AB5) (#x8FB9FB #x5AB8) (#x8FB9FC #x5ABA) (#x8FB9FD #x5ABB) (#x8FB9FE #x5ABF) (#x8FBAA1 #x5AC4) (#x8FBAA2 #x5AC6) (#x8FBAA3 #x5AC8) (#x8FBAA4 #x5ACF) (#x8FBAA5 #x5ADA) (#x8FBAA6 #x5ADC) (#x8FBAA7 #x5AE0) (#x8FBAA8 #x5AE5) (#x8FBAA9 #x5AEA) (#x8FBAAA #x5AEE) (#x8FBAAB #x5AF5) (#x8FBAAC #x5AF6) (#x8FBAAD #x5AFD) (#x8FBAAE #x5B00) (#x8FBAAF #x5B01) (#x8FBAB0 #x5B08) (#x8FBAB1 #x5B17) (#x8FBAB2 #x5B34) (#x8FBAB3 #x5B19) (#x8FBAB4 #x5B1B) (#x8FBAB5 #x5B1D) (#x8FBAB6 #x5B21) (#x8FBAB7 #x5B25) (#x8FBAB8 #x5B2D) (#x8FBAB9 #x5B38) (#x8FBABA #x5B41) (#x8FBABB #x5B4B) (#x8FBABC #x5B4C) (#x8FBABD #x5B52) (#x8FBABE #x5B56) (#x8FBABF #x5B5E) (#x8FBAC0 #x5B68) (#x8FBAC1 #x5B6E) (#x8FBAC2 #x5B6F) (#x8FBAC3 #x5B7C) (#x8FBAC4 #x5B7D) (#x8FBAC5 #x5B7E) (#x8FBAC6 #x5B7F) (#x8FBAC7 #x5B81) (#x8FBAC8 #x5B84) (#x8FBAC9 #x5B86) (#x8FBACA #x5B8A) (#x8FBACB #x5B8E) (#x8FBACC #x5B90) (#x8FBACD #x5B91) (#x8FBACE #x5B93) (#x8FBACF #x5B94) (#x8FBAD0 #x5B96) (#x8FBAD1 #x5BA8) (#x8FBAD2 #x5BA9) (#x8FBAD3 #x5BAC) (#x8FBAD4 #x5BAD) (#x8FBAD5 #x5BAF) (#x8FBAD6 #x5BB1) (#x8FBAD7 #x5BB2) (#x8FBAD8 #x5BB7) (#x8FBAD9 #x5BBA) (#x8FBADA #x5BBC) (#x8FBADB #x5BC0) (#x8FBADC #x5BC1) (#x8FBADD #x5BCD) (#x8FBADE #x5BCF) (#x8FBADF #x5BD6) (#x8FBAE0 #x5BD7) (#x8FBAE1 #x5BD8) (#x8FBAE2 #x5BD9) (#x8FBAE3 #x5BDA) (#x8FBAE4 #x5BE0) (#x8FBAE5 #x5BEF) (#x8FBAE6 #x5BF1) (#x8FBAE7 #x5BF4) (#x8FBAE8 #x5BFD) (#x8FBAE9 #x5C0C) (#x8FBAEA #x5C17) (#x8FBAEB #x5C1E) (#x8FBAEC #x5C1F) (#x8FBAED #x5C23) (#x8FBAEE #x5C26) (#x8FBAEF #x5C29) (#x8FBAF0 #x5C2B) (#x8FBAF1 #x5C2C) (#x8FBAF2 #x5C2E) (#x8FBAF3 #x5C30) (#x8FBAF4 #x5C32) (#x8FBAF5 #x5C35) (#x8FBAF6 #x5C36) (#x8FBAF7 #x5C59) (#x8FBAF8 #x5C5A) (#x8FBAF9 #x5C5C) (#x8FBAFA #x5C62) (#x8FBAFB #x5C63) (#x8FBAFC #x5C67) (#x8FBAFD #x5C68) (#x8FBAFE #x5C69) (#x8FBBA1 #x5C6D) (#x8FBBA2 #x5C70) (#x8FBBA3 #x5C74) (#x8FBBA4 #x5C75) (#x8FBBA5 #x5C7A) (#x8FBBA6 #x5C7B) (#x8FBBA7 #x5C7C) (#x8FBBA8 #x5C7D) (#x8FBBA9 #x5C87) (#x8FBBAA #x5C88) (#x8FBBAB #x5C8A) (#x8FBBAC #x5C8F) (#x8FBBAD #x5C92) (#x8FBBAE #x5C9D) (#x8FBBAF #x5C9F) (#x8FBBB0 #x5CA0) (#x8FBBB1 #x5CA2) (#x8FBBB2 #x5CA3) (#x8FBBB3 #x5CA6) (#x8FBBB4 #x5CAA) (#x8FBBB5 #x5CB2) (#x8FBBB6 #x5CB4) (#x8FBBB7 #x5CB5) (#x8FBBB8 #x5CBA) (#x8FBBB9 #x5CC9) (#x8FBBBA #x5CCB) (#x8FBBBB #x5CD2) (#x8FBBBC #x5CDD) (#x8FBBBD #x5CD7) (#x8FBBBE #x5CEE) (#x8FBBBF #x5CF1) (#x8FBBC0 #x5CF2) (#x8FBBC1 #x5CF4) (#x8FBBC2 #x5D01) (#x8FBBC3 #x5D06) (#x8FBBC4 #x5D0D) (#x8FBBC5 #x5D12) (#x8FBBC6 #x5D2B) (#x8FBBC7 #x5D23) (#x8FBBC8 #x5D24) (#x8FBBC9 #x5D26) (#x8FBBCA #x5D27) (#x8FBBCB #x5D31) (#x8FBBCC #x5D34) (#x8FBBCD #x5D39) (#x8FBBCE #x5D3D) (#x8FBBCF #x5D3F) (#x8FBBD0 #x5D42) (#x8FBBD1 #x5D43) (#x8FBBD2 #x5D46) (#x8FBBD3 #x5D48) (#x8FBBD4 #x5D55) (#x8FBBD5 #x5D51) (#x8FBBD6 #x5D59) (#x8FBBD7 #x5D4A) (#x8FBBD8 #x5D5F) (#x8FBBD9 #x5D60) (#x8FBBDA #x5D61) (#x8FBBDB #x5D62) (#x8FBBDC #x5D64) (#x8FBBDD #x5D6A) (#x8FBBDE #x5D6D) (#x8FBBDF #x5D70) (#x8FBBE0 #x5D79) (#x8FBBE1 #x5D7A) (#x8FBBE2 #x5D7E) (#x8FBBE3 #x5D7F) (#x8FBBE4 #x5D81) (#x8FBBE5 #x5D83) (#x8FBBE6 #x5D88) (#x8FBBE7 #x5D8A) (#x8FBBE8 #x5D92) (#x8FBBE9 #x5D93) (#x8FBBEA #x5D94) (#x8FBBEB #x5D95) (#x8FBBEC #x5D99) (#x8FBBED #x5D9B) (#x8FBBEE #x5D9F) (#x8FBBEF #x5DA0) (#x8FBBF0 #x5DA7) (#x8FBBF1 #x5DAB) (#x8FBBF2 #x5DB0) (#x8FBBF3 #x5DB4) (#x8FBBF4 #x5DB8) (#x8FBBF5 #x5DB9) (#x8FBBF6 #x5DC3) (#x8FBBF7 #x5DC7) (#x8FBBF8 #x5DCB) (#x8FBBF9 #x5DD0) (#x8FBBFA #x5DCE) (#x8FBBFB #x5DD8) (#x8FBBFC #x5DD9) (#x8FBBFD #x5DE0) (#x8FBBFE #x5DE4) (#x8FBCA1 #x5DE9) (#x8FBCA2 #x5DF8) (#x8FBCA3 #x5DF9) (#x8FBCA4 #x5E00) (#x8FBCA5 #x5E07) (#x8FBCA6 #x5E0D) (#x8FBCA7 #x5E12) (#x8FBCA8 #x5E14) (#x8FBCA9 #x5E15) (#x8FBCAA #x5E18) (#x8FBCAB #x5E1F) (#x8FBCAC #x5E20) (#x8FBCAD #x5E2E) (#x8FBCAE #x5E28) (#x8FBCAF #x5E32) (#x8FBCB0 #x5E35) (#x8FBCB1 #x5E3E) (#x8FBCB2 #x5E4B) (#x8FBCB3 #x5E50) (#x8FBCB4 #x5E49) (#x8FBCB5 #x5E51) (#x8FBCB6 #x5E56) (#x8FBCB7 #x5E58) (#x8FBCB8 #x5E5B) (#x8FBCB9 #x5E5C) (#x8FBCBA #x5E5E) (#x8FBCBB #x5E68) (#x8FBCBC #x5E6A) (#x8FBCBD #x5E6B) (#x8FBCBE #x5E6C) (#x8FBCBF #x5E6D) (#x8FBCC0 #x5E6E) (#x8FBCC1 #x5E70) (#x8FBCC2 #x5E80) (#x8FBCC3 #x5E8B) (#x8FBCC4 #x5E8E) (#x8FBCC5 #x5EA2) (#x8FBCC6 #x5EA4) (#x8FBCC7 #x5EA5) (#x8FBCC8 #x5EA8) (#x8FBCC9 #x5EAA) (#x8FBCCA #x5EAC) (#x8FBCCB #x5EB1) (#x8FBCCC #x5EB3) (#x8FBCCD #x5EBD) (#x8FBCCE #x5EBE) (#x8FBCCF #x5EBF) (#x8FBCD0 #x5EC6) (#x8FBCD1 #x5ECC) (#x8FBCD2 #x5ECB) (#x8FBCD3 #x5ECE) (#x8FBCD4 #x5ED1) (#x8FBCD5 #x5ED2) (#x8FBCD6 #x5ED4) (#x8FBCD7 #x5ED5) (#x8FBCD8 #x5EDC) (#x8FBCD9 #x5EDE) (#x8FBCDA #x5EE5) (#x8FBCDB #x5EEB) (#x8FBCDC #x5F02) (#x8FBCDD #x5F06) (#x8FBCDE #x5F07) (#x8FBCDF #x5F08) (#x8FBCE0 #x5F0E) (#x8FBCE1 #x5F19) (#x8FBCE2 #x5F1C) (#x8FBCE3 #x5F1D) (#x8FBCE4 #x5F21) (#x8FBCE5 #x5F22) (#x8FBCE6 #x5F23) (#x8FBCE7 #x5F24) (#x8FBCE8 #x5F28) (#x8FBCE9 #x5F2B) (#x8FBCEA #x5F2C) (#x8FBCEB #x5F2E) (#x8FBCEC #x5F30) (#x8FBCED #x5F34) (#x8FBCEE #x5F36) (#x8FBCEF #x5F3B) (#x8FBCF0 #x5F3D) (#x8FBCF1 #x5F3F) (#x8FBCF2 #x5F40) (#x8FBCF3 #x5F44) (#x8FBCF4 #x5F45) (#x8FBCF5 #x5F47) (#x8FBCF6 #x5F4D) (#x8FBCF7 #x5F50) (#x8FBCF8 #x5F54) (#x8FBCF9 #x5F58) (#x8FBCFA #x5F5B) (#x8FBCFB #x5F60) (#x8FBCFC #x5F63) (#x8FBCFD #x5F64) (#x8FBCFE #x5F67) (#x8FBDA1 #x5F6F) (#x8FBDA2 #x5F72) (#x8FBDA3 #x5F74) (#x8FBDA4 #x5F75) (#x8FBDA5 #x5F78) (#x8FBDA6 #x5F7A) (#x8FBDA7 #x5F7D) (#x8FBDA8 #x5F7E) (#x8FBDA9 #x5F89) (#x8FBDAA #x5F8D) (#x8FBDAB #x5F8F) (#x8FBDAC #x5F96) (#x8FBDAD #x5F9C) (#x8FBDAE #x5F9D) (#x8FBDAF #x5FA2) (#x8FBDB0 #x5FA7) (#x8FBDB1 #x5FAB) (#x8FBDB2 #x5FA4) (#x8FBDB3 #x5FAC) (#x8FBDB4 #x5FAF) (#x8FBDB5 #x5FB0) (#x8FBDB6 #x5FB1) (#x8FBDB7 #x5FB8) (#x8FBDB8 #x5FC4) (#x8FBDB9 #x5FC7) (#x8FBDBA #x5FC8) (#x8FBDBB #x5FC9) (#x8FBDBC #x5FCB) (#x8FBDBD #x5FD0) (#x8FBDBE #x5FD1) (#x8FBDBF #x5FD2) (#x8FBDC0 #x5FD3) (#x8FBDC1 #x5FD4) (#x8FBDC2 #x5FDE) (#x8FBDC3 #x5FE1) (#x8FBDC4 #x5FE2) (#x8FBDC5 #x5FE8) (#x8FBDC6 #x5FE9) (#x8FBDC7 #x5FEA) (#x8FBDC8 #x5FEC) (#x8FBDC9 #x5FED) (#x8FBDCA #x5FEE) (#x8FBDCB #x5FEF) (#x8FBDCC #x5FF2) (#x8FBDCD #x5FF3) (#x8FBDCE #x5FF6) (#x8FBDCF #x5FFA) (#x8FBDD0 #x5FFC) (#x8FBDD1 #x6007) (#x8FBDD2 #x600A) (#x8FBDD3 #x600D) (#x8FBDD4 #x6013) (#x8FBDD5 #x6014) (#x8FBDD6 #x6017) (#x8FBDD7 #x6018) (#x8FBDD8 #x601A) (#x8FBDD9 #x601F) (#x8FBDDA #x6024) (#x8FBDDB #x602D) (#x8FBDDC #x6033) (#x8FBDDD #x6035) (#x8FBDDE #x6040) (#x8FBDDF #x6047) (#x8FBDE0 #x6048) (#x8FBDE1 #x6049) (#x8FBDE2 #x604C) (#x8FBDE3 #x6051) (#x8FBDE4 #x6054) (#x8FBDE5 #x6056) (#x8FBDE6 #x6057) (#x8FBDE7 #x605D) (#x8FBDE8 #x6061) (#x8FBDE9 #x6067) (#x8FBDEA #x6071) (#x8FBDEB #x607E) (#x8FBDEC #x607F) (#x8FBDED #x6082) (#x8FBDEE #x6086) (#x8FBDEF #x6088) (#x8FBDF0 #x608A) (#x8FBDF1 #x608E) (#x8FBDF2 #x6091) (#x8FBDF3 #x6093) (#x8FBDF4 #x6095) (#x8FBDF5 #x6098) (#x8FBDF6 #x609D) (#x8FBDF7 #x609E) (#x8FBDF8 #x60A2) (#x8FBDF9 #x60A4) (#x8FBDFA #x60A5) (#x8FBDFB #x60A8) (#x8FBDFC #x60B0) (#x8FBDFD #x60B1) (#x8FBDFE #x60B7) (#x8FBEA1 #x60BB) (#x8FBEA2 #x60BE) (#x8FBEA3 #x60C2) (#x8FBEA4 #x60C4) (#x8FBEA5 #x60C8) (#x8FBEA6 #x60C9) (#x8FBEA7 #x60CA) (#x8FBEA8 #x60CB) (#x8FBEA9 #x60CE) (#x8FBEAA #x60CF) (#x8FBEAB #x60D4) (#x8FBEAC #x60D5) (#x8FBEAD #x60D9) (#x8FBEAE #x60DB) (#x8FBEAF #x60DD) (#x8FBEB0 #x60DE) (#x8FBEB1 #x60E2) (#x8FBEB2 #x60E5) (#x8FBEB3 #x60F2) (#x8FBEB4 #x60F5) (#x8FBEB5 #x60F8) (#x8FBEB6 #x60FC) (#x8FBEB7 #x60FD) (#x8FBEB8 #x6102) (#x8FBEB9 #x6107) (#x8FBEBA #x610A) (#x8FBEBB #x610C) (#x8FBEBC #x6110) (#x8FBEBD #x6111) (#x8FBEBE #x6112) (#x8FBEBF #x6113) (#x8FBEC0 #x6114) (#x8FBEC1 #x6116) (#x8FBEC2 #x6117) (#x8FBEC3 #x6119) (#x8FBEC4 #x611C) (#x8FBEC5 #x611E) (#x8FBEC6 #x6122) (#x8FBEC7 #x612A) (#x8FBEC8 #x612B) (#x8FBEC9 #x6130) (#x8FBECA #x6131) (#x8FBECB #x6135) (#x8FBECC #x6136) (#x8FBECD #x6137) (#x8FBECE #x6139) (#x8FBECF #x6141) (#x8FBED0 #x6145) (#x8FBED1 #x6146) (#x8FBED2 #x6149) (#x8FBED3 #x615E) (#x8FBED4 #x6160) (#x8FBED5 #x616C) (#x8FBED6 #x6172) (#x8FBED7 #x6178) (#x8FBED8 #x617B) (#x8FBED9 #x617C) (#x8FBEDA #x617F) (#x8FBEDB #x6180) (#x8FBEDC #x6181) (#x8FBEDD #x6183) (#x8FBEDE #x6184) (#x8FBEDF #x618B) (#x8FBEE0 #x618D) (#x8FBEE1 #x6192) (#x8FBEE2 #x6193) (#x8FBEE3 #x6197) (#x8FBEE4 #x6198) (#x8FBEE5 #x619C) (#x8FBEE6 #x619D) (#x8FBEE7 #x619F) (#x8FBEE8 #x61A0) (#x8FBEE9 #x61A5) (#x8FBEEA #x61A8) (#x8FBEEB #x61AA) (#x8FBEEC #x61AD) (#x8FBEED #x61B8) (#x8FBEEE #x61B9) (#x8FBEEF #x61BC) (#x8FBEF0 #x61C0) (#x8FBEF1 #x61C1) (#x8FBEF2 #x61C2) (#x8FBEF3 #x61CE) (#x8FBEF4 #x61CF) (#x8FBEF5 #x61D5) (#x8FBEF6 #x61DC) (#x8FBEF7 #x61DD) (#x8FBEF8 #x61DE) (#x8FBEF9 #x61DF) (#x8FBEFA #x61E1) (#x8FBEFB #x61E2) (#x8FBEFC #x61E7) (#x8FBEFD #x61E9) (#x8FBEFE #x61E5) (#x8FBFA1 #x61EC) (#x8FBFA2 #x61ED) (#x8FBFA3 #x61EF) (#x8FBFA4 #x6201) (#x8FBFA5 #x6203) (#x8FBFA6 #x6204) (#x8FBFA7 #x6207) (#x8FBFA8 #x6213) (#x8FBFA9 #x6215) (#x8FBFAA #x621C) (#x8FBFAB #x6220) (#x8FBFAC #x6222) (#x8FBFAD #x6223) (#x8FBFAE #x6227) (#x8FBFAF #x6229) (#x8FBFB0 #x622B) (#x8FBFB1 #x6239) (#x8FBFB2 #x623D) (#x8FBFB3 #x6242) (#x8FBFB4 #x6243) (#x8FBFB5 #x6244) (#x8FBFB6 #x6246) (#x8FBFB7 #x624C) (#x8FBFB8 #x6250) (#x8FBFB9 #x6251) (#x8FBFBA #x6252) (#x8FBFBB #x6254) (#x8FBFBC #x6256) (#x8FBFBD #x625A) (#x8FBFBE #x625C) (#x8FBFBF #x6264) (#x8FBFC0 #x626D) (#x8FBFC1 #x626F) (#x8FBFC2 #x6273) (#x8FBFC3 #x627A) (#x8FBFC4 #x627D) (#x8FBFC5 #x628D) (#x8FBFC6 #x628E) (#x8FBFC7 #x628F) (#x8FBFC8 #x6290) (#x8FBFC9 #x62A6) (#x8FBFCA #x62A8) (#x8FBFCB #x62B3) (#x8FBFCC #x62B6) (#x8FBFCD #x62B7) (#x8FBFCE #x62BA) (#x8FBFCF #x62BE) (#x8FBFD0 #x62BF) (#x8FBFD1 #x62C4) (#x8FBFD2 #x62CE) (#x8FBFD3 #x62D5) (#x8FBFD4 #x62D6) (#x8FBFD5 #x62DA) (#x8FBFD6 #x62EA) (#x8FBFD7 #x62F2) (#x8FBFD8 #x62F4) (#x8FBFD9 #x62FC) (#x8FBFDA #x62FD) (#x8FBFDB #x6303) (#x8FBFDC #x6304) (#x8FBFDD #x630A) (#x8FBFDE #x630B) (#x8FBFDF #x630D) (#x8FBFE0 #x6310) (#x8FBFE1 #x6313) (#x8FBFE2 #x6316) (#x8FBFE3 #x6318) (#x8FBFE4 #x6329) (#x8FBFE5 #x632A) (#x8FBFE6 #x632D) (#x8FBFE7 #x6335) (#x8FBFE8 #x6336) (#x8FBFE9 #x6339) (#x8FBFEA #x633C) (#x8FBFEB #x6341) (#x8FBFEC #x6342) (#x8FBFED #x6343) (#x8FBFEE #x6344) (#x8FBFEF #x6346) (#x8FBFF0 #x634A) (#x8FBFF1 #x634B) (#x8FBFF2 #x634E) (#x8FBFF3 #x6352) (#x8FBFF4 #x6353) (#x8FBFF5 #x6354) (#x8FBFF6 #x6358) (#x8FBFF7 #x635B) (#x8FBFF8 #x6365) (#x8FBFF9 #x6366) (#x8FBFFA #x636C) (#x8FBFFB #x636D) (#x8FBFFC #x6371) (#x8FBFFD #x6374) (#x8FBFFE #x6375) (#x8FC0A1 #x6378) (#x8FC0A2 #x637C) (#x8FC0A3 #x637D) (#x8FC0A4 #x637F) (#x8FC0A5 #x6382) (#x8FC0A6 #x6384) (#x8FC0A7 #x6387) (#x8FC0A8 #x638A) (#x8FC0A9 #x6390) (#x8FC0AA #x6394) (#x8FC0AB #x6395) (#x8FC0AC #x6399) (#x8FC0AD #x639A) (#x8FC0AE #x639E) (#x8FC0AF #x63A4) (#x8FC0B0 #x63A6) (#x8FC0B1 #x63AD) (#x8FC0B2 #x63AE) (#x8FC0B3 #x63AF) (#x8FC0B4 #x63BD) (#x8FC0B5 #x63C1) (#x8FC0B6 #x63C5) (#x8FC0B7 #x63C8) (#x8FC0B8 #x63CE) (#x8FC0B9 #x63D1) (#x8FC0BA #x63D3) (#x8FC0BB #x63D4) (#x8FC0BC #x63D5) (#x8FC0BD #x63DC) (#x8FC0BE #x63E0) (#x8FC0BF #x63E5) (#x8FC0C0 #x63EA) (#x8FC0C1 #x63EC) (#x8FC0C2 #x63F2) (#x8FC0C3 #x63F3) (#x8FC0C4 #x63F5) (#x8FC0C5 #x63F8) (#x8FC0C6 #x63F9) (#x8FC0C7 #x6409) (#x8FC0C8 #x640A) (#x8FC0C9 #x6410) (#x8FC0CA #x6412) (#x8FC0CB #x6414) (#x8FC0CC #x6418) (#x8FC0CD #x641E) (#x8FC0CE #x6420) (#x8FC0CF #x6422) (#x8FC0D0 #x6424) (#x8FC0D1 #x6425) (#x8FC0D2 #x6429) (#x8FC0D3 #x642A) (#x8FC0D4 #x642F) (#x8FC0D5 #x6430) (#x8FC0D6 #x6435) (#x8FC0D7 #x643D) (#x8FC0D8 #x643F) (#x8FC0D9 #x644B) (#x8FC0DA #x644F) (#x8FC0DB #x6451) (#x8FC0DC #x6452) (#x8FC0DD #x6453) (#x8FC0DE #x6454) (#x8FC0DF #x645A) (#x8FC0E0 #x645B) (#x8FC0E1 #x645C) (#x8FC0E2 #x645D) (#x8FC0E3 #x645F) (#x8FC0E4 #x6460) (#x8FC0E5 #x6461) (#x8FC0E6 #x6463) (#x8FC0E7 #x646D) (#x8FC0E8 #x6473) (#x8FC0E9 #x6474) (#x8FC0EA #x647B) (#x8FC0EB #x647D) (#x8FC0EC #x6485) (#x8FC0ED #x6487) (#x8FC0EE #x648F) (#x8FC0EF #x6490) (#x8FC0F0 #x6491) (#x8FC0F1 #x6498) (#x8FC0F2 #x6499) (#x8FC0F3 #x649B) (#x8FC0F4 #x649D) (#x8FC0F5 #x649F) (#x8FC0F6 #x64A1) (#x8FC0F7 #x64A3) (#x8FC0F8 #x64A6) (#x8FC0F9 #x64A8) (#x8FC0FA #x64AC) (#x8FC0FB #x64B3) (#x8FC0FC #x64BD) (#x8FC0FD #x64BE) (#x8FC0FE #x64BF) (#x8FC1A1 #x64C4) (#x8FC1A2 #x64C9) (#x8FC1A3 #x64CA) (#x8FC1A4 #x64CB) (#x8FC1A5 #x64CC) (#x8FC1A6 #x64CE) (#x8FC1A7 #x64D0) (#x8FC1A8 #x64D1) (#x8FC1A9 #x64D5) (#x8FC1AA #x64D7) (#x8FC1AB #x64E4) (#x8FC1AC #x64E5) (#x8FC1AD #x64E9) (#x8FC1AE #x64EA) (#x8FC1AF #x64ED) (#x8FC1B0 #x64F0) (#x8FC1B1 #x64F5) (#x8FC1B2 #x64F7) (#x8FC1B3 #x64FB) (#x8FC1B4 #x64FF) (#x8FC1B5 #x6501) (#x8FC1B6 #x6504) (#x8FC1B7 #x6508) (#x8FC1B8 #x6509) (#x8FC1B9 #x650A) (#x8FC1BA #x650F) (#x8FC1BB #x6513) (#x8FC1BC #x6514) (#x8FC1BD #x6516) (#x8FC1BE #x6519) (#x8FC1BF #x651B) (#x8FC1C0 #x651E) (#x8FC1C1 #x651F) (#x8FC1C2 #x6522) (#x8FC1C3 #x6526) (#x8FC1C4 #x6529) (#x8FC1C5 #x652E) (#x8FC1C6 #x6531) (#x8FC1C7 #x653A) (#x8FC1C8 #x653C) (#x8FC1C9 #x653D) (#x8FC1CA #x6543) (#x8FC1CB #x6547) (#x8FC1CC #x6549) (#x8FC1CD #x6550) (#x8FC1CE #x6552) (#x8FC1CF #x6554) (#x8FC1D0 #x655F) (#x8FC1D1 #x6560) (#x8FC1D2 #x6567) (#x8FC1D3 #x656B) (#x8FC1D4 #x657A) (#x8FC1D5 #x657D) (#x8FC1D6 #x6581) (#x8FC1D7 #x6585) (#x8FC1D8 #x658A) (#x8FC1D9 #x6592) (#x8FC1DA #x6595) (#x8FC1DB #x6598) (#x8FC1DC #x659D) (#x8FC1DD #x65A0) (#x8FC1DE #x65A3) (#x8FC1DF #x65A6) (#x8FC1E0 #x65AE) (#x8FC1E1 #x65B2) (#x8FC1E2 #x65B3) (#x8FC1E3 #x65B4) (#x8FC1E4 #x65BF) (#x8FC1E5 #x65C2) (#x8FC1E6 #x65C8) (#x8FC1E7 #x65C9) (#x8FC1E8 #x65CE) (#x8FC1E9 #x65D0) (#x8FC1EA #x65D4) (#x8FC1EB #x65D6) (#x8FC1EC #x65D8) (#x8FC1ED #x65DF) (#x8FC1EE #x65F0) (#x8FC1EF #x65F2) (#x8FC1F0 #x65F4) (#x8FC1F1 #x65F5) (#x8FC1F2 #x65F9) (#x8FC1F3 #x65FE) (#x8FC1F4 #x65FF) (#x8FC1F5 #x6600) (#x8FC1F6 #x6604) (#x8FC1F7 #x6608) (#x8FC1F8 #x6609) (#x8FC1F9 #x660D) (#x8FC1FA #x6611) (#x8FC1FB #x6612) (#x8FC1FC #x6615) (#x8FC1FD #x6616) (#x8FC1FE #x661D) (#x8FC2A1 #x661E) (#x8FC2A2 #x6621) (#x8FC2A3 #x6622) (#x8FC2A4 #x6623) (#x8FC2A5 #x6624) (#x8FC2A6 #x6626) (#x8FC2A7 #x6629) (#x8FC2A8 #x662A) (#x8FC2A9 #x662B) (#x8FC2AA #x662C) (#x8FC2AB #x662E) (#x8FC2AC #x6630) (#x8FC2AD #x6631) (#x8FC2AE #x6633) (#x8FC2AF #x6639) (#x8FC2B0 #x6637) (#x8FC2B1 #x6640) (#x8FC2B2 #x6645) (#x8FC2B3 #x6646) (#x8FC2B4 #x664A) (#x8FC2B5 #x664C) (#x8FC2B6 #x6651) (#x8FC2B7 #x664E) (#x8FC2B8 #x6657) (#x8FC2B9 #x6658) (#x8FC2BA #x6659) (#x8FC2BB #x665B) (#x8FC2BC #x665C) (#x8FC2BD #x6660) (#x8FC2BE #x6661) (#x8FC2BF #x66FB) (#x8FC2C0 #x666A) (#x8FC2C1 #x666B) (#x8FC2C2 #x666C) (#x8FC2C3 #x667E) (#x8FC2C4 #x6673) (#x8FC2C5 #x6675) (#x8FC2C6 #x667F) (#x8FC2C7 #x6677) (#x8FC2C8 #x6678) (#x8FC2C9 #x6679) (#x8FC2CA #x667B) (#x8FC2CB #x6680) (#x8FC2CC #x667C) (#x8FC2CD #x668B) (#x8FC2CE #x668C) (#x8FC2CF #x668D) (#x8FC2D0 #x6690) (#x8FC2D1 #x6692) (#x8FC2D2 #x6699) (#x8FC2D3 #x669A) (#x8FC2D4 #x669B) (#x8FC2D5 #x669C) (#x8FC2D6 #x669F) (#x8FC2D7 #x66A0) (#x8FC2D8 #x66A4) (#x8FC2D9 #x66AD) (#x8FC2DA #x66B1) (#x8FC2DB #x66B2) (#x8FC2DC #x66B5) (#x8FC2DD #x66BB) (#x8FC2DE #x66BF) (#x8FC2DF #x66C0) (#x8FC2E0 #x66C2) (#x8FC2E1 #x66C3) (#x8FC2E2 #x66C8) (#x8FC2E3 #x66CC) (#x8FC2E4 #x66CE) (#x8FC2E5 #x66CF) (#x8FC2E6 #x66D4) (#x8FC2E7 #x66DB) (#x8FC2E8 #x66DF) (#x8FC2E9 #x66E8) (#x8FC2EA #x66EB) (#x8FC2EB #x66EC) (#x8FC2EC #x66EE) (#x8FC2ED #x66FA) (#x8FC2EE #x6705) (#x8FC2EF #x6707) (#x8FC2F0 #x670E) (#x8FC2F1 #x6713) (#x8FC2F2 #x6719) (#x8FC2F3 #x671C) (#x8FC2F4 #x6720) (#x8FC2F5 #x6722) (#x8FC2F6 #x6733) (#x8FC2F7 #x673E) (#x8FC2F8 #x6745) (#x8FC2F9 #x6747) (#x8FC2FA #x6748) (#x8FC2FB #x674C) (#x8FC2FC #x6754) (#x8FC2FD #x6755) (#x8FC2FE #x675D) (#x8FC3A1 #x6766) (#x8FC3A2 #x676C) (#x8FC3A3 #x676E) (#x8FC3A4 #x6774) (#x8FC3A5 #x6776) (#x8FC3A6 #x677B) (#x8FC3A7 #x6781) (#x8FC3A8 #x6784) (#x8FC3A9 #x678E) (#x8FC3AA #x678F) (#x8FC3AB #x6791) (#x8FC3AC #x6793) (#x8FC3AD #x6796) (#x8FC3AE #x6798) (#x8FC3AF #x6799) (#x8FC3B0 #x679B) (#x8FC3B1 #x67B0) (#x8FC3B2 #x67B1) (#x8FC3B3 #x67B2) (#x8FC3B4 #x67B5) (#x8FC3B5 #x67BB) (#x8FC3B6 #x67BC) (#x8FC3B7 #x67BD) (#x8FC3B8 #x67F9) (#x8FC3B9 #x67C0) (#x8FC3BA #x67C2) (#x8FC3BB #x67C3) (#x8FC3BC #x67C5) (#x8FC3BD #x67C8) (#x8FC3BE #x67C9) (#x8FC3BF #x67D2) (#x8FC3C0 #x67D7) (#x8FC3C1 #x67D9) (#x8FC3C2 #x67DC) (#x8FC3C3 #x67E1) (#x8FC3C4 #x67E6) (#x8FC3C5 #x67F0) (#x8FC3C6 #x67F2) (#x8FC3C7 #x67F6) (#x8FC3C8 #x67F7) (#x8FC3C9 #x6852) (#x8FC3CA #x6814) (#x8FC3CB #x6819) (#x8FC3CC #x681D) (#x8FC3CD #x681F) (#x8FC3CE #x6828) (#x8FC3CF #x6827) (#x8FC3D0 #x682C) (#x8FC3D1 #x682D) (#x8FC3D2 #x682F) (#x8FC3D3 #x6830) (#x8FC3D4 #x6831) (#x8FC3D5 #x6833) (#x8FC3D6 #x683B) (#x8FC3D7 #x683F) (#x8FC3D8 #x6844) (#x8FC3D9 #x6845) (#x8FC3DA #x684A) (#x8FC3DB #x684C) (#x8FC3DC #x6855) (#x8FC3DD #x6857) (#x8FC3DE #x6858) (#x8FC3DF #x685B) (#x8FC3E0 #x686B) (#x8FC3E1 #x686E) (#x8FC3E2 #x686F) (#x8FC3E3 #x6870) (#x8FC3E4 #x6871) (#x8FC3E5 #x6872) (#x8FC3E6 #x6875) (#x8FC3E7 #x6879) (#x8FC3E8 #x687A) (#x8FC3E9 #x687B) (#x8FC3EA #x687C) (#x8FC3EB #x6882) (#x8FC3EC #x6884) (#x8FC3ED #x6886) (#x8FC3EE #x6888) (#x8FC3EF #x6896) (#x8FC3F0 #x6898) (#x8FC3F1 #x689A) (#x8FC3F2 #x689C) (#x8FC3F3 #x68A1) (#x8FC3F4 #x68A3) (#x8FC3F5 #x68A5) (#x8FC3F6 #x68A9) (#x8FC3F7 #x68AA) (#x8FC3F8 #x68AE) (#x8FC3F9 #x68B2) (#x8FC3FA #x68BB) (#x8FC3FB #x68C5) (#x8FC3FC #x68C8) (#x8FC3FD #x68CC) (#x8FC3FE #x68CF) (#x8FC4A1 #x68D0) (#x8FC4A2 #x68D1) (#x8FC4A3 #x68D3) (#x8FC4A4 #x68D6) (#x8FC4A5 #x68D9) (#x8FC4A6 #x68DC) (#x8FC4A7 #x68DD) (#x8FC4A8 #x68E5) (#x8FC4A9 #x68E8) (#x8FC4AA #x68EA) (#x8FC4AB #x68EB) (#x8FC4AC #x68EC) (#x8FC4AD #x68ED) (#x8FC4AE #x68F0) (#x8FC4AF #x68F1) (#x8FC4B0 #x68F5) (#x8FC4B1 #x68F6) (#x8FC4B2 #x68FB) (#x8FC4B3 #x68FC) (#x8FC4B4 #x68FD) (#x8FC4B5 #x6906) (#x8FC4B6 #x6909) (#x8FC4B7 #x690A) (#x8FC4B8 #x6910) (#x8FC4B9 #x6911) (#x8FC4BA #x6913) (#x8FC4BB #x6916) (#x8FC4BC #x6917) (#x8FC4BD #x6931) (#x8FC4BE #x6933) (#x8FC4BF #x6935) (#x8FC4C0 #x6938) (#x8FC4C1 #x693B) (#x8FC4C2 #x6942) (#x8FC4C3 #x6945) (#x8FC4C4 #x6949) (#x8FC4C5 #x694E) (#x8FC4C6 #x6957) (#x8FC4C7 #x695B) (#x8FC4C8 #x6963) (#x8FC4C9 #x6964) (#x8FC4CA #x6965) (#x8FC4CB #x6966) (#x8FC4CC #x6968) (#x8FC4CD #x6969) (#x8FC4CE #x696C) (#x8FC4CF #x6970) (#x8FC4D0 #x6971) (#x8FC4D1 #x6972) (#x8FC4D2 #x697A) (#x8FC4D3 #x697B) (#x8FC4D4 #x697F) (#x8FC4D5 #x6980) (#x8FC4D6 #x698D) (#x8FC4D7 #x6992) (#x8FC4D8 #x6996) (#x8FC4D9 #x6998) (#x8FC4DA #x69A1) (#x8FC4DB #x69A5) (#x8FC4DC #x69A6) (#x8FC4DD #x69A8) (#x8FC4DE #x69AB) (#x8FC4DF #x69AD) (#x8FC4E0 #x69AF) (#x8FC4E1 #x69B7) (#x8FC4E2 #x69B8) (#x8FC4E3 #x69BA) (#x8FC4E4 #x69BC) (#x8FC4E5 #x69C5) (#x8FC4E6 #x69C8) (#x8FC4E7 #x69D1) (#x8FC4E8 #x69D6) (#x8FC4E9 #x69D7) (#x8FC4EA #x69E2) (#x8FC4EB #x69E5) (#x8FC4EC #x69EE) (#x8FC4ED #x69EF) (#x8FC4EE #x69F1) (#x8FC4EF #x69F3) (#x8FC4F0 #x69F5) (#x8FC4F1 #x69FE) (#x8FC4F2 #x6A00) (#x8FC4F3 #x6A01) (#x8FC4F4 #x6A03) (#x8FC4F5 #x6A0F) (#x8FC4F6 #x6A11) (#x8FC4F7 #x6A15) (#x8FC4F8 #x6A1A) (#x8FC4F9 #x6A1D) (#x8FC4FA #x6A20) (#x8FC4FB #x6A24) (#x8FC4FC #x6A28) (#x8FC4FD #x6A30) (#x8FC4FE #x6A32) (#x8FC5A1 #x6A34) (#x8FC5A2 #x6A37) (#x8FC5A3 #x6A3B) (#x8FC5A4 #x6A3E) (#x8FC5A5 #x6A3F) (#x8FC5A6 #x6A45) (#x8FC5A7 #x6A46) (#x8FC5A8 #x6A49) (#x8FC5A9 #x6A4A) (#x8FC5AA #x6A4E) (#x8FC5AB #x6A50) (#x8FC5AC #x6A51) (#x8FC5AD #x6A52) (#x8FC5AE #x6A55) (#x8FC5AF #x6A56) (#x8FC5B0 #x6A5B) (#x8FC5B1 #x6A64) (#x8FC5B2 #x6A67) (#x8FC5B3 #x6A6A) (#x8FC5B4 #x6A71) (#x8FC5B5 #x6A73) (#x8FC5B6 #x6A7E) (#x8FC5B7 #x6A81) (#x8FC5B8 #x6A83) (#x8FC5B9 #x6A86) (#x8FC5BA #x6A87) (#x8FC5BB #x6A89) (#x8FC5BC #x6A8B) (#x8FC5BD #x6A91) (#x8FC5BE #x6A9B) (#x8FC5BF #x6A9D) (#x8FC5C0 #x6A9E) (#x8FC5C1 #x6A9F) (#x8FC5C2 #x6AA5) (#x8FC5C3 #x6AAB) (#x8FC5C4 #x6AAF) (#x8FC5C5 #x6AB0) (#x8FC5C6 #x6AB1) (#x8FC5C7 #x6AB4) (#x8FC5C8 #x6ABD) (#x8FC5C9 #x6ABE) (#x8FC5CA #x6ABF) (#x8FC5CB #x6AC6) (#x8FC5CC #x6AC9) (#x8FC5CD #x6AC8) (#x8FC5CE #x6ACC) (#x8FC5CF #x6AD0) (#x8FC5D0 #x6AD4) (#x8FC5D1 #x6AD5) (#x8FC5D2 #x6AD6) (#x8FC5D3 #x6ADC) (#x8FC5D4 #x6ADD) (#x8FC5D5 #x6AE4) (#x8FC5D6 #x6AE7) (#x8FC5D7 #x6AEC) (#x8FC5D8 #x6AF0) (#x8FC5D9 #x6AF1) (#x8FC5DA #x6AF2) (#x8FC5DB #x6AFC) (#x8FC5DC #x6AFD) (#x8FC5DD #x6B02) (#x8FC5DE #x6B03) (#x8FC5DF #x6B06) (#x8FC5E0 #x6B07) (#x8FC5E1 #x6B09) (#x8FC5E2 #x6B0F) (#x8FC5E3 #x6B10) (#x8FC5E4 #x6B11) (#x8FC5E5 #x6B17) (#x8FC5E6 #x6B1B) (#x8FC5E7 #x6B1E) (#x8FC5E8 #x6B24) (#x8FC5E9 #x6B28) (#x8FC5EA #x6B2B) (#x8FC5EB #x6B2C) (#x8FC5EC #x6B2F) (#x8FC5ED #x6B35) (#x8FC5EE #x6B36) (#x8FC5EF #x6B3B) (#x8FC5F0 #x6B3F) (#x8FC5F1 #x6B46) (#x8FC5F2 #x6B4A) (#x8FC5F3 #x6B4D) (#x8FC5F4 #x6B52) (#x8FC5F5 #x6B56) (#x8FC5F6 #x6B58) (#x8FC5F7 #x6B5D) (#x8FC5F8 #x6B60) (#x8FC5F9 #x6B67) (#x8FC5FA #x6B6B) (#x8FC5FB #x6B6E) (#x8FC5FC #x6B70) (#x8FC5FD #x6B75) (#x8FC5FE #x6B7D) (#x8FC6A1 #x6B7E) (#x8FC6A2 #x6B82) (#x8FC6A3 #x6B85) (#x8FC6A4 #x6B97) (#x8FC6A5 #x6B9B) (#x8FC6A6 #x6B9F) (#x8FC6A7 #x6BA0) (#x8FC6A8 #x6BA2) (#x8FC6A9 #x6BA3) (#x8FC6AA #x6BA8) (#x8FC6AB #x6BA9) (#x8FC6AC #x6BAC) (#x8FC6AD #x6BAD) (#x8FC6AE #x6BAE) (#x8FC6AF #x6BB0) (#x8FC6B0 #x6BB8) (#x8FC6B1 #x6BB9) (#x8FC6B2 #x6BBD) (#x8FC6B3 #x6BBE) (#x8FC6B4 #x6BC3) (#x8FC6B5 #x6BC4) (#x8FC6B6 #x6BC9) (#x8FC6B7 #x6BCC) (#x8FC6B8 #x6BD6) (#x8FC6B9 #x6BDA) (#x8FC6BA #x6BE1) (#x8FC6BB #x6BE3) (#x8FC6BC #x6BE6) (#x8FC6BD #x6BE7) (#x8FC6BE #x6BEE) (#x8FC6BF #x6BF1) (#x8FC6C0 #x6BF7) (#x8FC6C1 #x6BF9) (#x8FC6C2 #x6BFF) (#x8FC6C3 #x6C02) (#x8FC6C4 #x6C04) (#x8FC6C5 #x6C05) (#x8FC6C6 #x6C09) (#x8FC6C7 #x6C0D) (#x8FC6C8 #x6C0E) (#x8FC6C9 #x6C10) (#x8FC6CA #x6C12) (#x8FC6CB #x6C19) (#x8FC6CC #x6C1F) (#x8FC6CD #x6C26) (#x8FC6CE #x6C27) (#x8FC6CF #x6C28) (#x8FC6D0 #x6C2C) (#x8FC6D1 #x6C2E) (#x8FC6D2 #x6C33) (#x8FC6D3 #x6C35) (#x8FC6D4 #x6C36) (#x8FC6D5 #x6C3A) (#x8FC6D6 #x6C3B) (#x8FC6D7 #x6C3F) (#x8FC6D8 #x6C4A) (#x8FC6D9 #x6C4B) (#x8FC6DA #x6C4D) (#x8FC6DB #x6C4F) (#x8FC6DC #x6C52) (#x8FC6DD #x6C54) (#x8FC6DE #x6C59) (#x8FC6DF #x6C5B) (#x8FC6E0 #x6C5C) (#x8FC6E1 #x6C6B) (#x8FC6E2 #x6C6D) (#x8FC6E3 #x6C6F) (#x8FC6E4 #x6C74) (#x8FC6E5 #x6C76) (#x8FC6E6 #x6C78) (#x8FC6E7 #x6C79) (#x8FC6E8 #x6C7B) (#x8FC6E9 #x6C85) (#x8FC6EA #x6C86) (#x8FC6EB #x6C87) (#x8FC6EC #x6C89) (#x8FC6ED #x6C94) (#x8FC6EE #x6C95) (#x8FC6EF #x6C97) (#x8FC6F0 #x6C98) (#x8FC6F1 #x6C9C) (#x8FC6F2 #x6C9F) (#x8FC6F3 #x6CB0) (#x8FC6F4 #x6CB2) (#x8FC6F5 #x6CB4) (#x8FC6F6 #x6CC2) (#x8FC6F7 #x6CC6) (#x8FC6F8 #x6CCD) (#x8FC6F9 #x6CCF) (#x8FC6FA #x6CD0) (#x8FC6FB #x6CD1) (#x8FC6FC #x6CD2) (#x8FC6FD #x6CD4) (#x8FC6FE #x6CD6) (#x8FC7A1 #x6CDA) (#x8FC7A2 #x6CDC) (#x8FC7A3 #x6CE0) (#x8FC7A4 #x6CE7) (#x8FC7A5 #x6CE9) (#x8FC7A6 #x6CEB) (#x8FC7A7 #x6CEC) (#x8FC7A8 #x6CEE) (#x8FC7A9 #x6CF2) (#x8FC7AA #x6CF4) (#x8FC7AB #x6D04) (#x8FC7AC #x6D07) (#x8FC7AD #x6D0A) (#x8FC7AE #x6D0E) (#x8FC7AF #x6D0F) (#x8FC7B0 #x6D11) (#x8FC7B1 #x6D13) (#x8FC7B2 #x6D1A) (#x8FC7B3 #x6D26) (#x8FC7B4 #x6D27) (#x8FC7B5 #x6D28) (#x8FC7B6 #x6C67) (#x8FC7B7 #x6D2E) (#x8FC7B8 #x6D2F) (#x8FC7B9 #x6D31) (#x8FC7BA #x6D39) (#x8FC7BB #x6D3C) (#x8FC7BC #x6D3F) (#x8FC7BD #x6D57) (#x8FC7BE #x6D5E) (#x8FC7BF #x6D5F) (#x8FC7C0 #x6D61) (#x8FC7C1 #x6D65) (#x8FC7C2 #x6D67) (#x8FC7C3 #x6D6F) (#x8FC7C4 #x6D70) (#x8FC7C5 #x6D7C) (#x8FC7C6 #x6D82) (#x8FC7C7 #x6D87) (#x8FC7C8 #x6D91) (#x8FC7C9 #x6D92) (#x8FC7CA #x6D94) (#x8FC7CB #x6D96) (#x8FC7CC #x6D97) (#x8FC7CD #x6D98) (#x8FC7CE #x6DAA) (#x8FC7CF #x6DAC) (#x8FC7D0 #x6DB4) (#x8FC7D1 #x6DB7) (#x8FC7D2 #x6DB9) (#x8FC7D3 #x6DBD) (#x8FC7D4 #x6DBF) (#x8FC7D5 #x6DC4) (#x8FC7D6 #x6DC8) (#x8FC7D7 #x6DCA) (#x8FC7D8 #x6DCE) (#x8FC7D9 #x6DCF) (#x8FC7DA #x6DD6) (#x8FC7DB #x6DDB) (#x8FC7DC #x6DDD) (#x8FC7DD #x6DDF) (#x8FC7DE #x6DE0) (#x8FC7DF #x6DE2) (#x8FC7E0 #x6DE5) (#x8FC7E1 #x6DE9) (#x8FC7E2 #x6DEF) (#x8FC7E3 #x6DF0) (#x8FC7E4 #x6DF4) (#x8FC7E5 #x6DF6) (#x8FC7E6 #x6DFC) (#x8FC7E7 #x6E00) (#x8FC7E8 #x6E04) (#x8FC7E9 #x6E1E) (#x8FC7EA #x6E22) (#x8FC7EB #x6E27) (#x8FC7EC #x6E32) (#x8FC7ED #x6E36) (#x8FC7EE #x6E39) (#x8FC7EF #x6E3B) (#x8FC7F0 #x6E3C) (#x8FC7F1 #x6E44) (#x8FC7F2 #x6E45) (#x8FC7F3 #x6E48) (#x8FC7F4 #x6E49) (#x8FC7F5 #x6E4B) (#x8FC7F6 #x6E4F) (#x8FC7F7 #x6E51) (#x8FC7F8 #x6E52) (#x8FC7F9 #x6E53) (#x8FC7FA #x6E54) (#x8FC7FB #x6E57) (#x8FC7FC #x6E5C) (#x8FC7FD #x6E5D) (#x8FC7FE #x6E5E) (#x8FC8A1 #x6E62) (#x8FC8A2 #x6E63) (#x8FC8A3 #x6E68) (#x8FC8A4 #x6E73) (#x8FC8A5 #x6E7B) (#x8FC8A6 #x6E7D) (#x8FC8A7 #x6E8D) (#x8FC8A8 #x6E93) (#x8FC8A9 #x6E99) (#x8FC8AA #x6EA0) (#x8FC8AB #x6EA7) (#x8FC8AC #x6EAD) (#x8FC8AD #x6EAE) (#x8FC8AE #x6EB1) (#x8FC8AF #x6EB3) (#x8FC8B0 #x6EBB) (#x8FC8B1 #x6EBF) (#x8FC8B2 #x6EC0) (#x8FC8B3 #x6EC1) (#x8FC8B4 #x6EC3) (#x8FC8B5 #x6EC7) (#x8FC8B6 #x6EC8) (#x8FC8B7 #x6ECA) (#x8FC8B8 #x6ECD) (#x8FC8B9 #x6ECE) (#x8FC8BA #x6ECF) (#x8FC8BB #x6EEB) (#x8FC8BC #x6EED) (#x8FC8BD #x6EEE) (#x8FC8BE #x6EF9) (#x8FC8BF #x6EFB) (#x8FC8C0 #x6EFD) (#x8FC8C1 #x6F04) (#x8FC8C2 #x6F08) (#x8FC8C3 #x6F0A) (#x8FC8C4 #x6F0C) (#x8FC8C5 #x6F0D) (#x8FC8C6 #x6F16) (#x8FC8C7 #x6F18) (#x8FC8C8 #x6F1A) (#x8FC8C9 #x6F1B) (#x8FC8CA #x6F26) (#x8FC8CB #x6F29) (#x8FC8CC #x6F2A) (#x8FC8CD #x6F2F) (#x8FC8CE #x6F30) (#x8FC8CF #x6F33) (#x8FC8D0 #x6F36) (#x8FC8D1 #x6F3B) (#x8FC8D2 #x6F3C) (#x8FC8D3 #x6F2D) (#x8FC8D4 #x6F4F) (#x8FC8D5 #x6F51) (#x8FC8D6 #x6F52) (#x8FC8D7 #x6F53) (#x8FC8D8 #x6F57) (#x8FC8D9 #x6F59) (#x8FC8DA #x6F5A) (#x8FC8DB #x6F5D) (#x8FC8DC #x6F5E) (#x8FC8DD #x6F61) (#x8FC8DE #x6F62) (#x8FC8DF #x6F68) (#x8FC8E0 #x6F6C) (#x8FC8E1 #x6F7D) (#x8FC8E2 #x6F7E) (#x8FC8E3 #x6F83) (#x8FC8E4 #x6F87) (#x8FC8E5 #x6F88) (#x8FC8E6 #x6F8B) (#x8FC8E7 #x6F8C) (#x8FC8E8 #x6F8D) (#x8FC8E9 #x6F90) (#x8FC8EA #x6F92) (#x8FC8EB #x6F93) (#x8FC8EC #x6F94) (#x8FC8ED #x6F96) (#x8FC8EE #x6F9A) (#x8FC8EF #x6F9F) (#x8FC8F0 #x6FA0) (#x8FC8F1 #x6FA5) (#x8FC8F2 #x6FA6) (#x8FC8F3 #x6FA7) (#x8FC8F4 #x6FA8) (#x8FC8F5 #x6FAE) (#x8FC8F6 #x6FAF) (#x8FC8F7 #x6FB0) (#x8FC8F8 #x6FB5) (#x8FC8F9 #x6FB6) (#x8FC8FA #x6FBC) (#x8FC8FB #x6FC5) (#x8FC8FC #x6FC7) (#x8FC8FD #x6FC8) (#x8FC8FE #x6FCA) (#x8FC9A1 #x6FDA) (#x8FC9A2 #x6FDE) (#x8FC9A3 #x6FE8) (#x8FC9A4 #x6FE9) (#x8FC9A5 #x6FF0) (#x8FC9A6 #x6FF5) (#x8FC9A7 #x6FF9) (#x8FC9A8 #x6FFC) (#x8FC9A9 #x6FFD) (#x8FC9AA #x7000) (#x8FC9AB #x7005) (#x8FC9AC #x7006) (#x8FC9AD #x7007) (#x8FC9AE #x700D) (#x8FC9AF #x7017) (#x8FC9B0 #x7020) (#x8FC9B1 #x7023) (#x8FC9B2 #x702F) (#x8FC9B3 #x7034) (#x8FC9B4 #x7037) (#x8FC9B5 #x7039) (#x8FC9B6 #x703C) (#x8FC9B7 #x7043) (#x8FC9B8 #x7044) (#x8FC9B9 #x7048) (#x8FC9BA #x7049) (#x8FC9BB #x704A) (#x8FC9BC #x704B) (#x8FC9BD #x7054) (#x8FC9BE #x7055) (#x8FC9BF #x705D) (#x8FC9C0 #x705E) (#x8FC9C1 #x704E) (#x8FC9C2 #x7064) (#x8FC9C3 #x7065) (#x8FC9C4 #x706C) (#x8FC9C5 #x706E) (#x8FC9C6 #x7075) (#x8FC9C7 #x7076) (#x8FC9C8 #x707E) (#x8FC9C9 #x7081) (#x8FC9CA #x7085) (#x8FC9CB #x7086) (#x8FC9CC #x7094) (#x8FC9CD #x7095) (#x8FC9CE #x7096) (#x8FC9CF #x7097) (#x8FC9D0 #x7098) (#x8FC9D1 #x709B) (#x8FC9D2 #x70A4) (#x8FC9D3 #x70AB) (#x8FC9D4 #x70B0) (#x8FC9D5 #x70B1) (#x8FC9D6 #x70B4) (#x8FC9D7 #x70B7) (#x8FC9D8 #x70CA) (#x8FC9D9 #x70D1) (#x8FC9DA #x70D3) (#x8FC9DB #x70D4) (#x8FC9DC #x70D5) (#x8FC9DD #x70D6) (#x8FC9DE #x70D8) (#x8FC9DF #x70DC) (#x8FC9E0 #x70E4) (#x8FC9E1 #x70FA) (#x8FC9E2 #x7103) (#x8FC9E3 #x7104) (#x8FC9E4 #x7105) (#x8FC9E5 #x7106) (#x8FC9E6 #x7107) (#x8FC9E7 #x710B) (#x8FC9E8 #x710C) (#x8FC9E9 #x710F) (#x8FC9EA #x711E) (#x8FC9EB #x7120) (#x8FC9EC #x712B) (#x8FC9ED #x712D) (#x8FC9EE #x712F) (#x8FC9EF #x7130) (#x8FC9F0 #x7131) (#x8FC9F1 #x7138) (#x8FC9F2 #x7141) (#x8FC9F3 #x7145) (#x8FC9F4 #x7146) (#x8FC9F5 #x7147) (#x8FC9F6 #x714A) (#x8FC9F7 #x714B) (#x8FC9F8 #x7150) (#x8FC9F9 #x7152) (#x8FC9FA #x7157) (#x8FC9FB #x715A) (#x8FC9FC #x715C) (#x8FC9FD #x715E) (#x8FC9FE #x7160) (#x8FCAA1 #x7168) (#x8FCAA2 #x7179) (#x8FCAA3 #x7180) (#x8FCAA4 #x7185) (#x8FCAA5 #x7187) (#x8FCAA6 #x718C) (#x8FCAA7 #x7192) (#x8FCAA8 #x719A) (#x8FCAA9 #x719B) (#x8FCAAA #x71A0) (#x8FCAAB #x71A2) (#x8FCAAC #x71AF) (#x8FCAAD #x71B0) (#x8FCAAE #x71B2) (#x8FCAAF #x71B3) (#x8FCAB0 #x71BA) (#x8FCAB1 #x71BF) (#x8FCAB2 #x71C0) (#x8FCAB3 #x71C1) (#x8FCAB4 #x71C4) (#x8FCAB5 #x71CB) (#x8FCAB6 #x71CC) (#x8FCAB7 #x71D3) (#x8FCAB8 #x71D6) (#x8FCAB9 #x71D9) (#x8FCABA #x71DA) (#x8FCABB #x71DC) (#x8FCABC #x71F8) (#x8FCABD #x71FE) (#x8FCABE #x7200) (#x8FCABF #x7207) (#x8FCAC0 #x7208) (#x8FCAC1 #x7209) (#x8FCAC2 #x7213) (#x8FCAC3 #x7217) (#x8FCAC4 #x721A) (#x8FCAC5 #x721D) (#x8FCAC6 #x721F) (#x8FCAC7 #x7224) (#x8FCAC8 #x722B) (#x8FCAC9 #x722F) (#x8FCACA #x7234) (#x8FCACB #x7238) (#x8FCACC #x7239) (#x8FCACD #x7241) (#x8FCACE #x7242) (#x8FCACF #x7243) (#x8FCAD0 #x7245) (#x8FCAD1 #x724E) (#x8FCAD2 #x724F) (#x8FCAD3 #x7250) (#x8FCAD4 #x7253) (#x8FCAD5 #x7255) (#x8FCAD6 #x7256) (#x8FCAD7 #x725A) (#x8FCAD8 #x725C) (#x8FCAD9 #x725E) (#x8FCADA #x7260) (#x8FCADB #x7263) (#x8FCADC #x7268) (#x8FCADD #x726B) (#x8FCADE #x726E) (#x8FCADF #x726F) (#x8FCAE0 #x7271) (#x8FCAE1 #x7277) (#x8FCAE2 #x7278) (#x8FCAE3 #x727B) (#x8FCAE4 #x727C) (#x8FCAE5 #x727F) (#x8FCAE6 #x7284) (#x8FCAE7 #x7289) (#x8FCAE8 #x728D) (#x8FCAE9 #x728E) (#x8FCAEA #x7293) (#x8FCAEB #x729B) (#x8FCAEC #x72A8) (#x8FCAED #x72AD) (#x8FCAEE #x72AE) (#x8FCAEF #x72B1) (#x8FCAF0 #x72B4) (#x8FCAF1 #x72BE) (#x8FCAF2 #x72C1) (#x8FCAF3 #x72C7) (#x8FCAF4 #x72C9) (#x8FCAF5 #x72CC) (#x8FCAF6 #x72D5) (#x8FCAF7 #x72D6) (#x8FCAF8 #x72D8) (#x8FCAF9 #x72DF) (#x8FCAFA #x72E5) (#x8FCAFB #x72F3) (#x8FCAFC #x72F4) (#x8FCAFD #x72FA) (#x8FCAFE #x72FB) (#x8FCBA1 #x72FE) (#x8FCBA2 #x7302) (#x8FCBA3 #x7304) (#x8FCBA4 #x7305) (#x8FCBA5 #x7307) (#x8FCBA6 #x730B) (#x8FCBA7 #x730D) (#x8FCBA8 #x7312) (#x8FCBA9 #x7313) (#x8FCBAA #x7318) (#x8FCBAB #x7319) (#x8FCBAC #x731E) (#x8FCBAD #x7322) (#x8FCBAE #x7324) (#x8FCBAF #x7327) (#x8FCBB0 #x7328) (#x8FCBB1 #x732C) (#x8FCBB2 #x7331) (#x8FCBB3 #x7332) (#x8FCBB4 #x7335) (#x8FCBB5 #x733A) (#x8FCBB6 #x733B) (#x8FCBB7 #x733D) (#x8FCBB8 #x7343) (#x8FCBB9 #x734D) (#x8FCBBA #x7350) (#x8FCBBB #x7352) (#x8FCBBC #x7356) (#x8FCBBD #x7358) (#x8FCBBE #x735D) (#x8FCBBF #x735E) (#x8FCBC0 #x735F) (#x8FCBC1 #x7360) (#x8FCBC2 #x7366) (#x8FCBC3 #x7367) (#x8FCBC4 #x7369) (#x8FCBC5 #x736B) (#x8FCBC6 #x736C) (#x8FCBC7 #x736E) (#x8FCBC8 #x736F) (#x8FCBC9 #x7371) (#x8FCBCA #x7377) (#x8FCBCB #x7379) (#x8FCBCC #x737C) (#x8FCBCD #x7380) (#x8FCBCE #x7381) (#x8FCBCF #x7383) (#x8FCBD0 #x7385) (#x8FCBD1 #x7386) (#x8FCBD2 #x738E) (#x8FCBD3 #x7390) (#x8FCBD4 #x7393) (#x8FCBD5 #x7395) (#x8FCBD6 #x7397) (#x8FCBD7 #x7398) (#x8FCBD8 #x739C) (#x8FCBD9 #x739E) (#x8FCBDA #x739F) (#x8FCBDB #x73A0) (#x8FCBDC #x73A2) (#x8FCBDD #x73A5) (#x8FCBDE #x73A6) (#x8FCBDF #x73AA) (#x8FCBE0 #x73AB) (#x8FCBE1 #x73AD) (#x8FCBE2 #x73B5) (#x8FCBE3 #x73B7) (#x8FCBE4 #x73B9) (#x8FCBE5 #x73BC) (#x8FCBE6 #x73BD) (#x8FCBE7 #x73BF) (#x8FCBE8 #x73C5) (#x8FCBE9 #x73C6) (#x8FCBEA #x73C9) (#x8FCBEB #x73CB) (#x8FCBEC #x73CC) (#x8FCBED #x73CF) (#x8FCBEE #x73D2) (#x8FCBEF #x73D3) (#x8FCBF0 #x73D6) (#x8FCBF1 #x73D9) (#x8FCBF2 #x73DD) (#x8FCBF3 #x73E1) (#x8FCBF4 #x73E3) (#x8FCBF5 #x73E6) (#x8FCBF6 #x73E7) (#x8FCBF7 #x73E9) (#x8FCBF8 #x73F4) (#x8FCBF9 #x73F5) (#x8FCBFA #x73F7) (#x8FCBFB #x73F9) (#x8FCBFC #x73FA) (#x8FCBFD #x73FB) (#x8FCBFE #x73FD) (#x8FCCA1 #x73FF) (#x8FCCA2 #x7400) (#x8FCCA3 #x7401) (#x8FCCA4 #x7404) (#x8FCCA5 #x7407) (#x8FCCA6 #x740A) (#x8FCCA7 #x7411) (#x8FCCA8 #x741A) (#x8FCCA9 #x741B) (#x8FCCAA #x7424) (#x8FCCAB #x7426) (#x8FCCAC #x7428) (#x8FCCAD #x7429) (#x8FCCAE #x742A) (#x8FCCAF #x742B) (#x8FCCB0 #x742C) (#x8FCCB1 #x742D) (#x8FCCB2 #x742E) (#x8FCCB3 #x742F) (#x8FCCB4 #x7430) (#x8FCCB5 #x7431) (#x8FCCB6 #x7439) (#x8FCCB7 #x7440) (#x8FCCB8 #x7443) (#x8FCCB9 #x7444) (#x8FCCBA #x7446) (#x8FCCBB #x7447) (#x8FCCBC #x744B) (#x8FCCBD #x744D) (#x8FCCBE #x7451) (#x8FCCBF #x7452) (#x8FCCC0 #x7457) (#x8FCCC1 #x745D) (#x8FCCC2 #x7462) (#x8FCCC3 #x7466) (#x8FCCC4 #x7467) (#x8FCCC5 #x7468) (#x8FCCC6 #x746B) (#x8FCCC7 #x746D) (#x8FCCC8 #x746E) (#x8FCCC9 #x7471) (#x8FCCCA #x7472) (#x8FCCCB #x7480) (#x8FCCCC #x7481) (#x8FCCCD #x7485) (#x8FCCCE #x7486) (#x8FCCCF #x7487) (#x8FCCD0 #x7489) (#x8FCCD1 #x748F) (#x8FCCD2 #x7490) (#x8FCCD3 #x7491) (#x8FCCD4 #x7492) (#x8FCCD5 #x7498) (#x8FCCD6 #x7499) (#x8FCCD7 #x749A) (#x8FCCD8 #x749C) (#x8FCCD9 #x749F) (#x8FCCDA #x74A0) (#x8FCCDB #x74A1) (#x8FCCDC #x74A3) (#x8FCCDD #x74A6) (#x8FCCDE #x74A8) (#x8FCCDF #x74A9) (#x8FCCE0 #x74AA) (#x8FCCE1 #x74AB) (#x8FCCE2 #x74AE) (#x8FCCE3 #x74AF) (#x8FCCE4 #x74B1) (#x8FCCE5 #x74B2) (#x8FCCE6 #x74B5) (#x8FCCE7 #x74B9) (#x8FCCE8 #x74BB) (#x8FCCE9 #x74BF) (#x8FCCEA #x74C8) (#x8FCCEB #x74C9) (#x8FCCEC #x74CC) (#x8FCCED #x74D0) (#x8FCCEE #x74D3) (#x8FCCEF #x74D8) (#x8FCCF0 #x74DA) (#x8FCCF1 #x74DB) (#x8FCCF2 #x74DE) (#x8FCCF3 #x74DF) (#x8FCCF4 #x74E4) (#x8FCCF5 #x74E8) (#x8FCCF6 #x74EA) (#x8FCCF7 #x74EB) (#x8FCCF8 #x74EF) (#x8FCCF9 #x74F4) (#x8FCCFA #x74FA) (#x8FCCFB #x74FB) (#x8FCCFC #x74FC) (#x8FCCFD #x74FF) (#x8FCCFE #x7506) (#x8FCDA1 #x7512) (#x8FCDA2 #x7516) (#x8FCDA3 #x7517) (#x8FCDA4 #x7520) (#x8FCDA5 #x7521) (#x8FCDA6 #x7524) (#x8FCDA7 #x7527) (#x8FCDA8 #x7529) (#x8FCDA9 #x752A) (#x8FCDAA #x752F) (#x8FCDAB #x7536) (#x8FCDAC #x7539) (#x8FCDAD #x753D) (#x8FCDAE #x753E) (#x8FCDAF #x753F) (#x8FCDB0 #x7540) (#x8FCDB1 #x7543) (#x8FCDB2 #x7547) (#x8FCDB3 #x7548) (#x8FCDB4 #x754E) (#x8FCDB5 #x7550) (#x8FCDB6 #x7552) (#x8FCDB7 #x7557) (#x8FCDB8 #x755E) (#x8FCDB9 #x755F) (#x8FCDBA #x7561) (#x8FCDBB #x756F) (#x8FCDBC #x7571) (#x8FCDBD #x7579) (#x8FCDBE #x757A) (#x8FCDBF #x757B) (#x8FCDC0 #x757C) (#x8FCDC1 #x757D) (#x8FCDC2 #x757E) (#x8FCDC3 #x7581) (#x8FCDC4 #x7585) (#x8FCDC5 #x7590) (#x8FCDC6 #x7592) (#x8FCDC7 #x7593) (#x8FCDC8 #x7595) (#x8FCDC9 #x7599) (#x8FCDCA #x759C) (#x8FCDCB #x75A2) (#x8FCDCC #x75A4) (#x8FCDCD #x75B4) (#x8FCDCE #x75BA) (#x8FCDCF #x75BF) (#x8FCDD0 #x75C0) (#x8FCDD1 #x75C1) (#x8FCDD2 #x75C4) (#x8FCDD3 #x75C6) (#x8FCDD4 #x75CC) (#x8FCDD5 #x75CE) (#x8FCDD6 #x75CF) (#x8FCDD7 #x75D7) (#x8FCDD8 #x75DC) (#x8FCDD9 #x75DF) (#x8FCDDA #x75E0) (#x8FCDDB #x75E1) (#x8FCDDC #x75E4) (#x8FCDDD #x75E7) (#x8FCDDE #x75EC) (#x8FCDDF #x75EE) (#x8FCDE0 #x75EF) (#x8FCDE1 #x75F1) (#x8FCDE2 #x75F9) (#x8FCDE3 #x7600) (#x8FCDE4 #x7602) (#x8FCDE5 #x7603) (#x8FCDE6 #x7604) (#x8FCDE7 #x7607) (#x8FCDE8 #x7608) (#x8FCDE9 #x760A) (#x8FCDEA #x760C) (#x8FCDEB #x760F) (#x8FCDEC #x7612) (#x8FCDED #x7613) (#x8FCDEE #x7615) (#x8FCDEF #x7616) (#x8FCDF0 #x7619) (#x8FCDF1 #x761B) (#x8FCDF2 #x761C) (#x8FCDF3 #x761D) (#x8FCDF4 #x761E) (#x8FCDF5 #x7623) (#x8FCDF6 #x7625) (#x8FCDF7 #x7626) (#x8FCDF8 #x7629) (#x8FCDF9 #x762D) (#x8FCDFA #x7632) (#x8FCDFB #x7633) (#x8FCDFC #x7635) (#x8FCDFD #x7638) (#x8FCDFE #x7639) (#x8FCEA1 #x763A) (#x8FCEA2 #x763C) (#x8FCEA3 #x764A) (#x8FCEA4 #x7640) (#x8FCEA5 #x7641) (#x8FCEA6 #x7643) (#x8FCEA7 #x7644) (#x8FCEA8 #x7645) (#x8FCEA9 #x7649) (#x8FCEAA #x764B) (#x8FCEAB #x7655) (#x8FCEAC #x7659) (#x8FCEAD #x765F) (#x8FCEAE #x7664) (#x8FCEAF #x7665) (#x8FCEB0 #x766D) (#x8FCEB1 #x766E) (#x8FCEB2 #x766F) (#x8FCEB3 #x7671) (#x8FCEB4 #x7674) (#x8FCEB5 #x7681) (#x8FCEB6 #x7685) (#x8FCEB7 #x768C) (#x8FCEB8 #x768D) (#x8FCEB9 #x7695) (#x8FCEBA #x769B) (#x8FCEBB #x769C) (#x8FCEBC #x769D) (#x8FCEBD #x769F) (#x8FCEBE #x76A0) (#x8FCEBF #x76A2) (#x8FCEC0 #x76A3) (#x8FCEC1 #x76A4) (#x8FCEC2 #x76A5) (#x8FCEC3 #x76A6) (#x8FCEC4 #x76A7) (#x8FCEC5 #x76A8) (#x8FCEC6 #x76AA) (#x8FCEC7 #x76AD) (#x8FCEC8 #x76BD) (#x8FCEC9 #x76C1) (#x8FCECA #x76C5) (#x8FCECB #x76C9) (#x8FCECC #x76CB) (#x8FCECD #x76CC) (#x8FCECE #x76CE) (#x8FCECF #x76D4) (#x8FCED0 #x76D9) (#x8FCED1 #x76E0) (#x8FCED2 #x76E6) (#x8FCED3 #x76E8) (#x8FCED4 #x76EC) (#x8FCED5 #x76F0) (#x8FCED6 #x76F1) (#x8FCED7 #x76F6) (#x8FCED8 #x76F9) (#x8FCED9 #x76FC) (#x8FCEDA #x7700) (#x8FCEDB #x7706) (#x8FCEDC #x770A) (#x8FCEDD #x770E) (#x8FCEDE #x7712) (#x8FCEDF #x7714) (#x8FCEE0 #x7715) (#x8FCEE1 #x7717) (#x8FCEE2 #x7719) (#x8FCEE3 #x771A) (#x8FCEE4 #x771C) (#x8FCEE5 #x7722) (#x8FCEE6 #x7728) (#x8FCEE7 #x772D) (#x8FCEE8 #x772E) (#x8FCEE9 #x772F) (#x8FCEEA #x7734) (#x8FCEEB #x7735) (#x8FCEEC #x7736) (#x8FCEED #x7739) (#x8FCEEE #x773D) (#x8FCEEF #x773E) (#x8FCEF0 #x7742) (#x8FCEF1 #x7745) (#x8FCEF2 #x7746) (#x8FCEF3 #x774A) (#x8FCEF4 #x774D) (#x8FCEF5 #x774E) (#x8FCEF6 #x774F) (#x8FCEF7 #x7752) (#x8FCEF8 #x7756) (#x8FCEF9 #x7757) (#x8FCEFA #x775C) (#x8FCEFB #x775E) (#x8FCEFC #x775F) (#x8FCEFD #x7760) (#x8FCEFE #x7762) (#x8FCFA1 #x7764) (#x8FCFA2 #x7767) (#x8FCFA3 #x776A) (#x8FCFA4 #x776C) (#x8FCFA5 #x7770) (#x8FCFA6 #x7772) (#x8FCFA7 #x7773) (#x8FCFA8 #x7774) (#x8FCFA9 #x777A) (#x8FCFAA #x777D) (#x8FCFAB #x7780) (#x8FCFAC #x7784) (#x8FCFAD #x778C) (#x8FCFAE #x778D) (#x8FCFAF #x7794) (#x8FCFB0 #x7795) (#x8FCFB1 #x7796) (#x8FCFB2 #x779A) (#x8FCFB3 #x779F) (#x8FCFB4 #x77A2) (#x8FCFB5 #x77A7) (#x8FCFB6 #x77AA) (#x8FCFB7 #x77AE) (#x8FCFB8 #x77AF) (#x8FCFB9 #x77B1) (#x8FCFBA #x77B5) (#x8FCFBB #x77BE) (#x8FCFBC #x77C3) (#x8FCFBD #x77C9) (#x8FCFBE #x77D1) (#x8FCFBF #x77D2) (#x8FCFC0 #x77D5) (#x8FCFC1 #x77D9) (#x8FCFC2 #x77DE) (#x8FCFC3 #x77DF) (#x8FCFC4 #x77E0) (#x8FCFC5 #x77E4) (#x8FCFC6 #x77E6) (#x8FCFC7 #x77EA) (#x8FCFC8 #x77EC) (#x8FCFC9 #x77F0) (#x8FCFCA #x77F1) (#x8FCFCB #x77F4) (#x8FCFCC #x77F8) (#x8FCFCD #x77FB) (#x8FCFCE #x7805) (#x8FCFCF #x7806) (#x8FCFD0 #x7809) (#x8FCFD1 #x780D) (#x8FCFD2 #x780E) (#x8FCFD3 #x7811) (#x8FCFD4 #x781D) (#x8FCFD5 #x7821) (#x8FCFD6 #x7822) (#x8FCFD7 #x7823) (#x8FCFD8 #x782D) (#x8FCFD9 #x782E) (#x8FCFDA #x7830) (#x8FCFDB #x7835) (#x8FCFDC #x7837) (#x8FCFDD #x7843) (#x8FCFDE #x7844) (#x8FCFDF #x7847) (#x8FCFE0 #x7848) (#x8FCFE1 #x784C) (#x8FCFE2 #x784E) (#x8FCFE3 #x7852) (#x8FCFE4 #x785C) (#x8FCFE5 #x785E) (#x8FCFE6 #x7860) (#x8FCFE7 #x7861) (#x8FCFE8 #x7863) (#x8FCFE9 #x7864) (#x8FCFEA #x7868) (#x8FCFEB #x786A) (#x8FCFEC #x786E) (#x8FCFED #x787A) (#x8FCFEE #x787E) (#x8FCFEF #x788A) (#x8FCFF0 #x788F) (#x8FCFF1 #x7894) (#x8FCFF2 #x7898) (#x8FCFF3 #x78A1) (#x8FCFF4 #x789D) (#x8FCFF5 #x789E) (#x8FCFF6 #x789F) (#x8FCFF7 #x78A4) (#x8FCFF8 #x78A8) (#x8FCFF9 #x78AC) (#x8FCFFA #x78AD) (#x8FCFFB #x78B0) (#x8FCFFC #x78B1) (#x8FCFFD #x78B2) (#x8FCFFE #x78B3) (#x8FD0A1 #x78BB) (#x8FD0A2 #x78BD) (#x8FD0A3 #x78BF) (#x8FD0A4 #x78C7) (#x8FD0A5 #x78C8) (#x8FD0A6 #x78C9) (#x8FD0A7 #x78CC) (#x8FD0A8 #x78CE) (#x8FD0A9 #x78D2) (#x8FD0AA #x78D3) (#x8FD0AB #x78D5) (#x8FD0AC #x78D6) (#x8FD0AD #x78E4) (#x8FD0AE #x78DB) (#x8FD0AF #x78DF) (#x8FD0B0 #x78E0) (#x8FD0B1 #x78E1) (#x8FD0B2 #x78E6) (#x8FD0B3 #x78EA) (#x8FD0B4 #x78F2) (#x8FD0B5 #x78F3) (#x8FD0B6 #x7900) (#x8FD0B7 #x78F6) (#x8FD0B8 #x78F7) (#x8FD0B9 #x78FA) (#x8FD0BA #x78FB) (#x8FD0BB #x78FF) (#x8FD0BC #x7906) (#x8FD0BD #x790C) (#x8FD0BE #x7910) (#x8FD0BF #x791A) (#x8FD0C0 #x791C) (#x8FD0C1 #x791E) (#x8FD0C2 #x791F) (#x8FD0C3 #x7920) (#x8FD0C4 #x7925) (#x8FD0C5 #x7927) (#x8FD0C6 #x7929) (#x8FD0C7 #x792D) (#x8FD0C8 #x7931) (#x8FD0C9 #x7934) (#x8FD0CA #x7935) (#x8FD0CB #x793B) (#x8FD0CC #x793D) (#x8FD0CD #x793F) (#x8FD0CE #x7944) (#x8FD0CF #x7945) (#x8FD0D0 #x7946) (#x8FD0D1 #x794A) (#x8FD0D2 #x794B) (#x8FD0D3 #x794F) (#x8FD0D4 #x7951) (#x8FD0D5 #x7954) (#x8FD0D6 #x7958) (#x8FD0D7 #x795B) (#x8FD0D8 #x795C) (#x8FD0D9 #x7967) (#x8FD0DA #x7969) (#x8FD0DB #x796B) (#x8FD0DC #x7972) (#x8FD0DD #x7979) (#x8FD0DE #x797B) (#x8FD0DF #x797C) (#x8FD0E0 #x797E) (#x8FD0E1 #x798B) (#x8FD0E2 #x798C) (#x8FD0E3 #x7991) (#x8FD0E4 #x7993) (#x8FD0E5 #x7994) (#x8FD0E6 #x7995) (#x8FD0E7 #x7996) (#x8FD0E8 #x7998) (#x8FD0E9 #x799B) (#x8FD0EA #x799C) (#x8FD0EB #x79A1) (#x8FD0EC #x79A8) (#x8FD0ED #x79A9) (#x8FD0EE #x79AB) (#x8FD0EF #x79AF) (#x8FD0F0 #x79B1) (#x8FD0F1 #x79B4) (#x8FD0F2 #x79B8) (#x8FD0F3 #x79BB) (#x8FD0F4 #x79C2) (#x8FD0F5 #x79C4) (#x8FD0F6 #x79C7) (#x8FD0F7 #x79C8) (#x8FD0F8 #x79CA) (#x8FD0F9 #x79CF) (#x8FD0FA #x79D4) (#x8FD0FB #x79D6) (#x8FD0FC #x79DA) (#x8FD0FD #x79DD) (#x8FD0FE #x79DE) (#x8FD1A1 #x79E0) (#x8FD1A2 #x79E2) (#x8FD1A3 #x79E5) (#x8FD1A4 #x79EA) (#x8FD1A5 #x79EB) (#x8FD1A6 #x79ED) (#x8FD1A7 #x79F1) (#x8FD1A8 #x79F8) (#x8FD1A9 #x79FC) (#x8FD1AA #x7A02) (#x8FD1AB #x7A03) (#x8FD1AC #x7A07) (#x8FD1AD #x7A09) (#x8FD1AE #x7A0A) (#x8FD1AF #x7A0C) (#x8FD1B0 #x7A11) (#x8FD1B1 #x7A15) (#x8FD1B2 #x7A1B) (#x8FD1B3 #x7A1E) (#x8FD1B4 #x7A21) (#x8FD1B5 #x7A27) (#x8FD1B6 #x7A2B) (#x8FD1B7 #x7A2D) (#x8FD1B8 #x7A2F) (#x8FD1B9 #x7A30) (#x8FD1BA #x7A34) (#x8FD1BB #x7A35) (#x8FD1BC #x7A38) (#x8FD1BD #x7A39) (#x8FD1BE #x7A3A) (#x8FD1BF #x7A44) (#x8FD1C0 #x7A45) (#x8FD1C1 #x7A47) (#x8FD1C2 #x7A48) (#x8FD1C3 #x7A4C) (#x8FD1C4 #x7A55) (#x8FD1C5 #x7A56) (#x8FD1C6 #x7A59) (#x8FD1C7 #x7A5C) (#x8FD1C8 #x7A5D) (#x8FD1C9 #x7A5F) (#x8FD1CA #x7A60) (#x8FD1CB #x7A65) (#x8FD1CC #x7A67) (#x8FD1CD #x7A6A) (#x8FD1CE #x7A6D) (#x8FD1CF #x7A75) (#x8FD1D0 #x7A78) (#x8FD1D1 #x7A7E) (#x8FD1D2 #x7A80) (#x8FD1D3 #x7A82) (#x8FD1D4 #x7A85) (#x8FD1D5 #x7A86) (#x8FD1D6 #x7A8A) (#x8FD1D7 #x7A8B) (#x8FD1D8 #x7A90) (#x8FD1D9 #x7A91) (#x8FD1DA #x7A94) (#x8FD1DB #x7A9E) (#x8FD1DC #x7AA0) (#x8FD1DD #x7AA3) (#x8FD1DE #x7AAC) (#x8FD1DF #x7AB3) (#x8FD1E0 #x7AB5) (#x8FD1E1 #x7AB9) (#x8FD1E2 #x7ABB) (#x8FD1E3 #x7ABC) (#x8FD1E4 #x7AC6) (#x8FD1E5 #x7AC9) (#x8FD1E6 #x7ACC) (#x8FD1E7 #x7ACE) (#x8FD1E8 #x7AD1) (#x8FD1E9 #x7ADB) (#x8FD1EA #x7AE8) (#x8FD1EB #x7AE9) (#x8FD1EC #x7AEB) (#x8FD1ED #x7AEC) (#x8FD1EE #x7AF1) (#x8FD1EF #x7AF4) (#x8FD1F0 #x7AFB) (#x8FD1F1 #x7AFD) (#x8FD1F2 #x7AFE) (#x8FD1F3 #x7B07) (#x8FD1F4 #x7B14) (#x8FD1F5 #x7B1F) (#x8FD1F6 #x7B23) (#x8FD1F7 #x7B27) (#x8FD1F8 #x7B29) (#x8FD1F9 #x7B2A) (#x8FD1FA #x7B2B) (#x8FD1FB #x7B2D) (#x8FD1FC #x7B2E) (#x8FD1FD #x7B2F) (#x8FD1FE #x7B30) (#x8FD2A1 #x7B31) (#x8FD2A2 #x7B34) (#x8FD2A3 #x7B3D) (#x8FD2A4 #x7B3F) (#x8FD2A5 #x7B40) (#x8FD2A6 #x7B41) (#x8FD2A7 #x7B47) (#x8FD2A8 #x7B4E) (#x8FD2A9 #x7B55) (#x8FD2AA #x7B60) (#x8FD2AB #x7B64) (#x8FD2AC #x7B66) (#x8FD2AD #x7B69) (#x8FD2AE #x7B6A) (#x8FD2AF #x7B6D) (#x8FD2B0 #x7B6F) (#x8FD2B1 #x7B72) (#x8FD2B2 #x7B73) (#x8FD2B3 #x7B77) (#x8FD2B4 #x7B84) (#x8FD2B5 #x7B89) (#x8FD2B6 #x7B8E) (#x8FD2B7 #x7B90) (#x8FD2B8 #x7B91) (#x8FD2B9 #x7B96) (#x8FD2BA #x7B9B) (#x8FD2BB #x7B9E) (#x8FD2BC #x7BA0) (#x8FD2BD #x7BA5) (#x8FD2BE #x7BAC) (#x8FD2BF #x7BAF) (#x8FD2C0 #x7BB0) (#x8FD2C1 #x7BB2) (#x8FD2C2 #x7BB5) (#x8FD2C3 #x7BB6) (#x8FD2C4 #x7BBA) (#x8FD2C5 #x7BBB) (#x8FD2C6 #x7BBC) (#x8FD2C7 #x7BBD) (#x8FD2C8 #x7BC2) (#x8FD2C9 #x7BC5) (#x8FD2CA #x7BC8) (#x8FD2CB #x7BCA) (#x8FD2CC #x7BD4) (#x8FD2CD #x7BD6) (#x8FD2CE #x7BD7) (#x8FD2CF #x7BD9) (#x8FD2D0 #x7BDA) (#x8FD2D1 #x7BDB) (#x8FD2D2 #x7BE8) (#x8FD2D3 #x7BEA) (#x8FD2D4 #x7BF2) (#x8FD2D5 #x7BF4) (#x8FD2D6 #x7BF5) (#x8FD2D7 #x7BF8) (#x8FD2D8 #x7BF9) (#x8FD2D9 #x7BFA) (#x8FD2DA #x7BFC) (#x8FD2DB #x7BFE) (#x8FD2DC #x7C01) (#x8FD2DD #x7C02) (#x8FD2DE #x7C03) (#x8FD2DF #x7C04) (#x8FD2E0 #x7C06) (#x8FD2E1 #x7C09) (#x8FD2E2 #x7C0B) (#x8FD2E3 #x7C0C) (#x8FD2E4 #x7C0E) (#x8FD2E5 #x7C0F) (#x8FD2E6 #x7C19) (#x8FD2E7 #x7C1B) (#x8FD2E8 #x7C20) (#x8FD2E9 #x7C25) (#x8FD2EA #x7C26) (#x8FD2EB #x7C28) (#x8FD2EC #x7C2C) (#x8FD2ED #x7C31) (#x8FD2EE #x7C33) (#x8FD2EF #x7C34) (#x8FD2F0 #x7C36) (#x8FD2F1 #x7C39) (#x8FD2F2 #x7C3A) (#x8FD2F3 #x7C46) (#x8FD2F4 #x7C4A) (#x8FD2F5 #x7C55) (#x8FD2F6 #x7C51) (#x8FD2F7 #x7C52) (#x8FD2F8 #x7C53) (#x8FD2F9 #x7C59) (#x8FD2FA #x7C5A) (#x8FD2FB #x7C5B) (#x8FD2FC #x7C5C) (#x8FD2FD #x7C5D) (#x8FD2FE #x7C5E) (#x8FD3A1 #x7C61) (#x8FD3A2 #x7C63) (#x8FD3A3 #x7C67) (#x8FD3A4 #x7C69) (#x8FD3A5 #x7C6D) (#x8FD3A6 #x7C6E) (#x8FD3A7 #x7C70) (#x8FD3A8 #x7C72) (#x8FD3A9 #x7C79) (#x8FD3AA #x7C7C) (#x8FD3AB #x7C7D) (#x8FD3AC #x7C86) (#x8FD3AD #x7C87) (#x8FD3AE #x7C8F) (#x8FD3AF #x7C94) (#x8FD3B0 #x7C9E) (#x8FD3B1 #x7CA0) (#x8FD3B2 #x7CA6) (#x8FD3B3 #x7CB0) (#x8FD3B4 #x7CB6) (#x8FD3B5 #x7CB7) (#x8FD3B6 #x7CBA) (#x8FD3B7 #x7CBB) (#x8FD3B8 #x7CBC) (#x8FD3B9 #x7CBF) (#x8FD3BA #x7CC4) (#x8FD3BB #x7CC7) (#x8FD3BC #x7CC8) (#x8FD3BD #x7CC9) (#x8FD3BE #x7CCD) (#x8FD3BF #x7CCF) (#x8FD3C0 #x7CD3) (#x8FD3C1 #x7CD4) (#x8FD3C2 #x7CD5) (#x8FD3C3 #x7CD7) (#x8FD3C4 #x7CD9) (#x8FD3C5 #x7CDA) (#x8FD3C6 #x7CDD) (#x8FD3C7 #x7CE6) (#x8FD3C8 #x7CE9) (#x8FD3C9 #x7CEB) (#x8FD3CA #x7CF5) (#x8FD3CB #x7D03) (#x8FD3CC #x7D07) (#x8FD3CD #x7D08) (#x8FD3CE #x7D09) (#x8FD3CF #x7D0F) (#x8FD3D0 #x7D11) (#x8FD3D1 #x7D12) (#x8FD3D2 #x7D13) (#x8FD3D3 #x7D16) (#x8FD3D4 #x7D1D) (#x8FD3D5 #x7D1E) (#x8FD3D6 #x7D23) (#x8FD3D7 #x7D26) (#x8FD3D8 #x7D2A) (#x8FD3D9 #x7D2D) (#x8FD3DA #x7D31) (#x8FD3DB #x7D3C) (#x8FD3DC #x7D3D) (#x8FD3DD #x7D3E) (#x8FD3DE #x7D40) (#x8FD3DF #x7D41) (#x8FD3E0 #x7D47) (#x8FD3E1 #x7D48) (#x8FD3E2 #x7D4D) (#x8FD3E3 #x7D51) (#x8FD3E4 #x7D53) (#x8FD3E5 #x7D57) (#x8FD3E6 #x7D59) (#x8FD3E7 #x7D5A) (#x8FD3E8 #x7D5C) (#x8FD3E9 #x7D5D) (#x8FD3EA #x7D65) (#x8FD3EB #x7D67) (#x8FD3EC #x7D6A) (#x8FD3ED #x7D70) (#x8FD3EE #x7D78) (#x8FD3EF #x7D7A) (#x8FD3F0 #x7D7B) (#x8FD3F1 #x7D7F) (#x8FD3F2 #x7D81) (#x8FD3F3 #x7D82) (#x8FD3F4 #x7D83) (#x8FD3F5 #x7D85) (#x8FD3F6 #x7D86) (#x8FD3F7 #x7D88) (#x8FD3F8 #x7D8B) (#x8FD3F9 #x7D8C) (#x8FD3FA #x7D8D) (#x8FD3FB #x7D91) (#x8FD3FC #x7D96) (#x8FD3FD #x7D97) (#x8FD3FE #x7D9D) (#x8FD4A1 #x7D9E) (#x8FD4A2 #x7DA6) (#x8FD4A3 #x7DA7) (#x8FD4A4 #x7DAA) (#x8FD4A5 #x7DB3) (#x8FD4A6 #x7DB6) (#x8FD4A7 #x7DB7) (#x8FD4A8 #x7DB9) (#x8FD4A9 #x7DC2) (#x8FD4AA #x7DC3) (#x8FD4AB #x7DC4) (#x8FD4AC #x7DC5) (#x8FD4AD #x7DC6) (#x8FD4AE #x7DCC) (#x8FD4AF #x7DCD) (#x8FD4B0 #x7DCE) (#x8FD4B1 #x7DD7) (#x8FD4B2 #x7DD9) (#x8FD4B3 #x7E00) (#x8FD4B4 #x7DE2) (#x8FD4B5 #x7DE5) (#x8FD4B6 #x7DE6) (#x8FD4B7 #x7DEA) (#x8FD4B8 #x7DEB) (#x8FD4B9 #x7DED) (#x8FD4BA #x7DF1) (#x8FD4BB #x7DF5) (#x8FD4BC #x7DF6) (#x8FD4BD #x7DF9) (#x8FD4BE #x7DFA) (#x8FD4BF #x7E08) (#x8FD4C0 #x7E10) (#x8FD4C1 #x7E11) (#x8FD4C2 #x7E15) (#x8FD4C3 #x7E17) (#x8FD4C4 #x7E1C) (#x8FD4C5 #x7E1D) (#x8FD4C6 #x7E20) (#x8FD4C7 #x7E27) (#x8FD4C8 #x7E28) (#x8FD4C9 #x7E2C) (#x8FD4CA #x7E2D) (#x8FD4CB #x7E2F) (#x8FD4CC #x7E33) (#x8FD4CD #x7E36) (#x8FD4CE #x7E3F) (#x8FD4CF #x7E44) (#x8FD4D0 #x7E45) (#x8FD4D1 #x7E47) (#x8FD4D2 #x7E4E) (#x8FD4D3 #x7E50) (#x8FD4D4 #x7E52) (#x8FD4D5 #x7E58) (#x8FD4D6 #x7E5F) (#x8FD4D7 #x7E61) (#x8FD4D8 #x7E62) (#x8FD4D9 #x7E65) (#x8FD4DA #x7E6B) (#x8FD4DB #x7E6E) (#x8FD4DC #x7E6F) (#x8FD4DD #x7E73) (#x8FD4DE #x7E78) (#x8FD4DF #x7E7E) (#x8FD4E0 #x7E81) (#x8FD4E1 #x7E86) (#x8FD4E2 #x7E87) (#x8FD4E3 #x7E8A) (#x8FD4E4 #x7E8D) (#x8FD4E5 #x7E91) (#x8FD4E6 #x7E95) (#x8FD4E7 #x7E98) (#x8FD4E8 #x7E9A) (#x8FD4E9 #x7E9D) (#x8FD4EA #x7E9E) (#x8FD4EB #x7F3C) (#x8FD4EC #x7F3B) (#x8FD4ED #x7F3D) (#x8FD4EE #x7F3E) (#x8FD4EF #x7F3F) (#x8FD4F0 #x7F43) (#x8FD4F1 #x7F44) (#x8FD4F2 #x7F47) (#x8FD4F3 #x7F4F) (#x8FD4F4 #x7F52) (#x8FD4F5 #x7F53) (#x8FD4F6 #x7F5B) (#x8FD4F7 #x7F5C) (#x8FD4F8 #x7F5D) (#x8FD4F9 #x7F61) (#x8FD4FA #x7F63) (#x8FD4FB #x7F64) (#x8FD4FC #x7F65) (#x8FD4FD #x7F66) (#x8FD4FE #x7F6D) (#x8FD5A1 #x7F71) (#x8FD5A2 #x7F7D) (#x8FD5A3 #x7F7E) (#x8FD5A4 #x7F7F) (#x8FD5A5 #x7F80) (#x8FD5A6 #x7F8B) (#x8FD5A7 #x7F8D) (#x8FD5A8 #x7F8F) (#x8FD5A9 #x7F90) (#x8FD5AA #x7F91) (#x8FD5AB #x7F96) (#x8FD5AC #x7F97) (#x8FD5AD #x7F9C) (#x8FD5AE #x7FA1) (#x8FD5AF #x7FA2) (#x8FD5B0 #x7FA6) (#x8FD5B1 #x7FAA) (#x8FD5B2 #x7FAD) (#x8FD5B3 #x7FB4) (#x8FD5B4 #x7FBC) (#x8FD5B5 #x7FBF) (#x8FD5B6 #x7FC0) (#x8FD5B7 #x7FC3) (#x8FD5B8 #x7FC8) (#x8FD5B9 #x7FCE) (#x8FD5BA #x7FCF) (#x8FD5BB #x7FDB) (#x8FD5BC #x7FDF) (#x8FD5BD #x7FE3) (#x8FD5BE #x7FE5) (#x8FD5BF #x7FE8) (#x8FD5C0 #x7FEC) (#x8FD5C1 #x7FEE) (#x8FD5C2 #x7FEF) (#x8FD5C3 #x7FF2) (#x8FD5C4 #x7FFA) (#x8FD5C5 #x7FFD) (#x8FD5C6 #x7FFE) (#x8FD5C7 #x7FFF) (#x8FD5C8 #x8007) (#x8FD5C9 #x8008) (#x8FD5CA #x800A) (#x8FD5CB #x800D) (#x8FD5CC #x800E) (#x8FD5CD #x800F) (#x8FD5CE #x8011) (#x8FD5CF #x8013) (#x8FD5D0 #x8014) (#x8FD5D1 #x8016) (#x8FD5D2 #x801D) (#x8FD5D3 #x801E) (#x8FD5D4 #x801F) (#x8FD5D5 #x8020) (#x8FD5D6 #x8024) (#x8FD5D7 #x8026) (#x8FD5D8 #x802C) (#x8FD5D9 #x802E) (#x8FD5DA #x8030) (#x8FD5DB #x8034) (#x8FD5DC #x8035) (#x8FD5DD #x8037) (#x8FD5DE #x8039) (#x8FD5DF #x803A) (#x8FD5E0 #x803C) (#x8FD5E1 #x803E) (#x8FD5E2 #x8040) (#x8FD5E3 #x8044) (#x8FD5E4 #x8060) (#x8FD5E5 #x8064) (#x8FD5E6 #x8066) (#x8FD5E7 #x806D) (#x8FD5E8 #x8071) (#x8FD5E9 #x8075) (#x8FD5EA #x8081) (#x8FD5EB #x8088) (#x8FD5EC #x808E) (#x8FD5ED #x809C) (#x8FD5EE #x809E) (#x8FD5EF #x80A6) (#x8FD5F0 #x80A7) (#x8FD5F1 #x80AB) (#x8FD5F2 #x80B8) (#x8FD5F3 #x80B9) (#x8FD5F4 #x80C8) (#x8FD5F5 #x80CD) (#x8FD5F6 #x80CF) (#x8FD5F7 #x80D2) (#x8FD5F8 #x80D4) (#x8FD5F9 #x80D5) (#x8FD5FA #x80D7) (#x8FD5FB #x80D8) (#x8FD5FC #x80E0) (#x8FD5FD #x80ED) (#x8FD5FE #x80EE) (#x8FD6A1 #x80F0) (#x8FD6A2 #x80F2) (#x8FD6A3 #x80F3) (#x8FD6A4 #x80F6) (#x8FD6A5 #x80F9) (#x8FD6A6 #x80FA) (#x8FD6A7 #x80FE) (#x8FD6A8 #x8103) (#x8FD6A9 #x810B) (#x8FD6AA #x8116) (#x8FD6AB #x8117) (#x8FD6AC #x8118) (#x8FD6AD #x811C) (#x8FD6AE #x811E) (#x8FD6AF #x8120) (#x8FD6B0 #x8124) (#x8FD6B1 #x8127) (#x8FD6B2 #x812C) (#x8FD6B3 #x8130) (#x8FD6B4 #x8135) (#x8FD6B5 #x813A) (#x8FD6B6 #x813C) (#x8FD6B7 #x8145) (#x8FD6B8 #x8147) (#x8FD6B9 #x814A) (#x8FD6BA #x814C) (#x8FD6BB #x8152) (#x8FD6BC #x8157) (#x8FD6BD #x8160) (#x8FD6BE #x8161) (#x8FD6BF #x8167) (#x8FD6C0 #x8168) (#x8FD6C1 #x8169) (#x8FD6C2 #x816D) (#x8FD6C3 #x816F) (#x8FD6C4 #x8177) (#x8FD6C5 #x8181) (#x8FD6C6 #x8190) (#x8FD6C7 #x8184) (#x8FD6C8 #x8185) (#x8FD6C9 #x8186) (#x8FD6CA #x818B) (#x8FD6CB #x818E) (#x8FD6CC #x8196) (#x8FD6CD #x8198) (#x8FD6CE #x819B) (#x8FD6CF #x819E) (#x8FD6D0 #x81A2) (#x8FD6D1 #x81AE) (#x8FD6D2 #x81B2) (#x8FD6D3 #x81B4) (#x8FD6D4 #x81BB) (#x8FD6D5 #x81CB) (#x8FD6D6 #x81C3) (#x8FD6D7 #x81C5) (#x8FD6D8 #x81CA) (#x8FD6D9 #x81CE) (#x8FD6DA #x81CF) (#x8FD6DB #x81D5) (#x8FD6DC #x81D7) (#x8FD6DD #x81DB) (#x8FD6DE #x81DD) (#x8FD6DF #x81DE) (#x8FD6E0 #x81E1) (#x8FD6E1 #x81E4) (#x8FD6E2 #x81EB) (#x8FD6E3 #x81EC) (#x8FD6E4 #x81F0) (#x8FD6E5 #x81F1) (#x8FD6E6 #x81F2) (#x8FD6E7 #x81F5) (#x8FD6E8 #x81F6) (#x8FD6E9 #x81F8) (#x8FD6EA #x81F9) (#x8FD6EB #x81FD) (#x8FD6EC #x81FF) (#x8FD6ED #x8200) (#x8FD6EE #x8203) (#x8FD6EF #x820F) (#x8FD6F0 #x8213) (#x8FD6F1 #x8214) (#x8FD6F2 #x8219) (#x8FD6F3 #x821A) (#x8FD6F4 #x821D) (#x8FD6F5 #x8221) (#x8FD6F6 #x8222) (#x8FD6F7 #x8228) (#x8FD6F8 #x8232) (#x8FD6F9 #x8234) (#x8FD6FA #x823A) (#x8FD6FB #x8243) (#x8FD6FC #x8244) (#x8FD6FD #x8245) (#x8FD6FE #x8246) (#x8FD7A1 #x824B) (#x8FD7A2 #x824E) (#x8FD7A3 #x824F) (#x8FD7A4 #x8251) (#x8FD7A5 #x8256) (#x8FD7A6 #x825C) (#x8FD7A7 #x8260) (#x8FD7A8 #x8263) (#x8FD7A9 #x8267) (#x8FD7AA #x826D) (#x8FD7AB #x8274) (#x8FD7AC #x827B) (#x8FD7AD #x827D) (#x8FD7AE #x827F) (#x8FD7AF #x8280) (#x8FD7B0 #x8281) (#x8FD7B1 #x8283) (#x8FD7B2 #x8284) (#x8FD7B3 #x8287) (#x8FD7B4 #x8289) (#x8FD7B5 #x828A) (#x8FD7B6 #x828E) (#x8FD7B7 #x8291) (#x8FD7B8 #x8294) (#x8FD7B9 #x8296) (#x8FD7BA #x8298) (#x8FD7BB #x829A) (#x8FD7BC #x829B) (#x8FD7BD #x82A0) (#x8FD7BE #x82A1) (#x8FD7BF #x82A3) (#x8FD7C0 #x82A4) (#x8FD7C1 #x82A7) (#x8FD7C2 #x82A8) (#x8FD7C3 #x82A9) (#x8FD7C4 #x82AA) (#x8FD7C5 #x82AE) (#x8FD7C6 #x82B0) (#x8FD7C7 #x82B2) (#x8FD7C8 #x82B4) (#x8FD7C9 #x82B7) (#x8FD7CA #x82BA) (#x8FD7CB #x82BC) (#x8FD7CC #x82BE) (#x8FD7CD #x82BF) (#x8FD7CE #x82C6) (#x8FD7CF #x82D0) (#x8FD7D0 #x82D5) (#x8FD7D1 #x82DA) (#x8FD7D2 #x82E0) (#x8FD7D3 #x82E2) (#x8FD7D4 #x82E4) (#x8FD7D5 #x82E8) (#x8FD7D6 #x82EA) (#x8FD7D7 #x82ED) (#x8FD7D8 #x82EF) (#x8FD7D9 #x82F6) (#x8FD7DA #x82F7) (#x8FD7DB #x82FD) (#x8FD7DC #x82FE) (#x8FD7DD #x8300) (#x8FD7DE #x8301) (#x8FD7DF #x8307) (#x8FD7E0 #x8308) (#x8FD7E1 #x830A) (#x8FD7E2 #x830B) (#x8FD7E3 #x8354) (#x8FD7E4 #x831B) (#x8FD7E5 #x831D) (#x8FD7E6 #x831E) (#x8FD7E7 #x831F) (#x8FD7E8 #x8321) (#x8FD7E9 #x8322) (#x8FD7EA #x832C) (#x8FD7EB #x832D) (#x8FD7EC #x832E) (#x8FD7ED #x8330) (#x8FD7EE #x8333) (#x8FD7EF #x8337) (#x8FD7F0 #x833A) (#x8FD7F1 #x833C) (#x8FD7F2 #x833D) (#x8FD7F3 #x8342) (#x8FD7F4 #x8343) (#x8FD7F5 #x8344) (#x8FD7F6 #x8347) (#x8FD7F7 #x834D) (#x8FD7F8 #x834E) (#x8FD7F9 #x8351) (#x8FD7FA #x8355) (#x8FD7FB #x8356) (#x8FD7FC #x8357) (#x8FD7FD #x8370) (#x8FD7FE #x8378) (#x8FD8A1 #x837D) (#x8FD8A2 #x837F) (#x8FD8A3 #x8380) (#x8FD8A4 #x8382) (#x8FD8A5 #x8384) (#x8FD8A6 #x8386) (#x8FD8A7 #x838D) (#x8FD8A8 #x8392) (#x8FD8A9 #x8394) (#x8FD8AA #x8395) (#x8FD8AB #x8398) (#x8FD8AC #x8399) (#x8FD8AD #x839B) (#x8FD8AE #x839C) (#x8FD8AF #x839D) (#x8FD8B0 #x83A6) (#x8FD8B1 #x83A7) (#x8FD8B2 #x83A9) (#x8FD8B3 #x83AC) (#x8FD8B4 #x83BE) (#x8FD8B5 #x83BF) (#x8FD8B6 #x83C0) (#x8FD8B7 #x83C7) (#x8FD8B8 #x83C9) (#x8FD8B9 #x83CF) (#x8FD8BA #x83D0) (#x8FD8BB #x83D1) (#x8FD8BC #x83D4) (#x8FD8BD #x83DD) (#x8FD8BE #x8353) (#x8FD8BF #x83E8) (#x8FD8C0 #x83EA) (#x8FD8C1 #x83F6) (#x8FD8C2 #x83F8) (#x8FD8C3 #x83F9) (#x8FD8C4 #x83FC) (#x8FD8C5 #x8401) (#x8FD8C6 #x8406) (#x8FD8C7 #x840A) (#x8FD8C8 #x840F) (#x8FD8C9 #x8411) (#x8FD8CA #x8415) (#x8FD8CB #x8419) (#x8FD8CC #x83AD) (#x8FD8CD #x842F) (#x8FD8CE #x8439) (#x8FD8CF #x8445) (#x8FD8D0 #x8447) (#x8FD8D1 #x8448) (#x8FD8D2 #x844A) (#x8FD8D3 #x844D) (#x8FD8D4 #x844F) (#x8FD8D5 #x8451) (#x8FD8D6 #x8452) (#x8FD8D7 #x8456) (#x8FD8D8 #x8458) (#x8FD8D9 #x8459) (#x8FD8DA #x845A) (#x8FD8DB #x845C) (#x8FD8DC #x8460) (#x8FD8DD #x8464) (#x8FD8DE #x8465) (#x8FD8DF #x8467) (#x8FD8E0 #x846A) (#x8FD8E1 #x8470) (#x8FD8E2 #x8473) (#x8FD8E3 #x8474) (#x8FD8E4 #x8476) (#x8FD8E5 #x8478) (#x8FD8E6 #x847C) (#x8FD8E7 #x847D) (#x8FD8E8 #x8481) (#x8FD8E9 #x8485) (#x8FD8EA #x8492) (#x8FD8EB #x8493) (#x8FD8EC #x8495) (#x8FD8ED #x849E) (#x8FD8EE #x84A6) (#x8FD8EF #x84A8) (#x8FD8F0 #x84A9) (#x8FD8F1 #x84AA) (#x8FD8F2 #x84AF) (#x8FD8F3 #x84B1) (#x8FD8F4 #x84B4) (#x8FD8F5 #x84BA) (#x8FD8F6 #x84BD) (#x8FD8F7 #x84BE) (#x8FD8F8 #x84C0) (#x8FD8F9 #x84C2) (#x8FD8FA #x84C7) (#x8FD8FB #x84C8) (#x8FD8FC #x84CC) (#x8FD8FD #x84CF) (#x8FD8FE #x84D3) (#x8FD9A1 #x84DC) (#x8FD9A2 #x84E7) (#x8FD9A3 #x84EA) (#x8FD9A4 #x84EF) (#x8FD9A5 #x84F0) (#x8FD9A6 #x84F1) (#x8FD9A7 #x84F2) (#x8FD9A8 #x84F7) (#x8FD9A9 #x8532) (#x8FD9AA #x84FA) (#x8FD9AB #x84FB) (#x8FD9AC #x84FD) (#x8FD9AD #x8502) (#x8FD9AE #x8503) (#x8FD9AF #x8507) (#x8FD9B0 #x850C) (#x8FD9B1 #x850E) (#x8FD9B2 #x8510) (#x8FD9B3 #x851C) (#x8FD9B4 #x851E) (#x8FD9B5 #x8522) (#x8FD9B6 #x8523) (#x8FD9B7 #x8524) (#x8FD9B8 #x8525) (#x8FD9B9 #x8527) (#x8FD9BA #x852A) (#x8FD9BB #x852B) (#x8FD9BC #x852F) (#x8FD9BD #x8533) (#x8FD9BE #x8534) (#x8FD9BF #x8536) (#x8FD9C0 #x853F) (#x8FD9C1 #x8546) (#x8FD9C2 #x854F) (#x8FD9C3 #x8550) (#x8FD9C4 #x8551) (#x8FD9C5 #x8552) (#x8FD9C6 #x8553) (#x8FD9C7 #x8556) (#x8FD9C8 #x8559) (#x8FD9C9 #x855C) (#x8FD9CA #x855D) (#x8FD9CB #x855E) (#x8FD9CC #x855F) (#x8FD9CD #x8560) (#x8FD9CE #x8561) (#x8FD9CF #x8562) (#x8FD9D0 #x8564) (#x8FD9D1 #x856B) (#x8FD9D2 #x856F) (#x8FD9D3 #x8579) (#x8FD9D4 #x857A) (#x8FD9D5 #x857B) (#x8FD9D6 #x857D) (#x8FD9D7 #x857F) (#x8FD9D8 #x8581) (#x8FD9D9 #x8585) (#x8FD9DA #x8586) (#x8FD9DB #x8589) (#x8FD9DC #x858B) (#x8FD9DD #x858C) (#x8FD9DE #x858F) (#x8FD9DF #x8593) (#x8FD9E0 #x8598) (#x8FD9E1 #x859D) (#x8FD9E2 #x859F) (#x8FD9E3 #x85A0) (#x8FD9E4 #x85A2) (#x8FD9E5 #x85A5) (#x8FD9E6 #x85A7) (#x8FD9E7 #x85B4) (#x8FD9E8 #x85B6) (#x8FD9E9 #x85B7) (#x8FD9EA #x85B8) (#x8FD9EB #x85BC) (#x8FD9EC #x85BD) (#x8FD9ED #x85BE) (#x8FD9EE #x85BF) (#x8FD9EF #x85C2) (#x8FD9F0 #x85C7) (#x8FD9F1 #x85CA) (#x8FD9F2 #x85CB) (#x8FD9F3 #x85CE) (#x8FD9F4 #x85AD) (#x8FD9F5 #x85D8) (#x8FD9F6 #x85DA) (#x8FD9F7 #x85DF) (#x8FD9F8 #x85E0) (#x8FD9F9 #x85E6) (#x8FD9FA #x85E8) (#x8FD9FB #x85ED) (#x8FD9FC #x85F3) (#x8FD9FD #x85F6) (#x8FD9FE #x85FC) (#x8FDAA1 #x85FF) (#x8FDAA2 #x8600) (#x8FDAA3 #x8604) (#x8FDAA4 #x8605) (#x8FDAA5 #x860D) (#x8FDAA6 #x860E) (#x8FDAA7 #x8610) (#x8FDAA8 #x8611) (#x8FDAA9 #x8612) (#x8FDAAA #x8618) (#x8FDAAB #x8619) (#x8FDAAC #x861B) (#x8FDAAD #x861E) (#x8FDAAE #x8621) (#x8FDAAF #x8627) (#x8FDAB0 #x8629) (#x8FDAB1 #x8636) (#x8FDAB2 #x8638) (#x8FDAB3 #x863A) (#x8FDAB4 #x863C) (#x8FDAB5 #x863D) (#x8FDAB6 #x8640) (#x8FDAB7 #x8642) (#x8FDAB8 #x8646) (#x8FDAB9 #x8652) (#x8FDABA #x8653) (#x8FDABB #x8656) (#x8FDABC #x8657) (#x8FDABD #x8658) (#x8FDABE #x8659) (#x8FDABF #x865D) (#x8FDAC0 #x8660) (#x8FDAC1 #x8661) (#x8FDAC2 #x8662) (#x8FDAC3 #x8663) (#x8FDAC4 #x8664) (#x8FDAC5 #x8669) (#x8FDAC6 #x866C) (#x8FDAC7 #x866F) (#x8FDAC8 #x8675) (#x8FDAC9 #x8676) (#x8FDACA #x8677) (#x8FDACB #x867A) (#x8FDACC #x868D) (#x8FDACD #x8691) (#x8FDACE #x8696) (#x8FDACF #x8698) (#x8FDAD0 #x869A) (#x8FDAD1 #x869C) (#x8FDAD2 #x86A1) (#x8FDAD3 #x86A6) (#x8FDAD4 #x86A7) (#x8FDAD5 #x86A8) (#x8FDAD6 #x86AD) (#x8FDAD7 #x86B1) (#x8FDAD8 #x86B3) (#x8FDAD9 #x86B4) (#x8FDADA #x86B5) (#x8FDADB #x86B7) (#x8FDADC #x86B8) (#x8FDADD #x86B9) (#x8FDADE #x86BF) (#x8FDADF #x86C0) (#x8FDAE0 #x86C1) (#x8FDAE1 #x86C3) (#x8FDAE2 #x86C5) (#x8FDAE3 #x86D1) (#x8FDAE4 #x86D2) (#x8FDAE5 #x86D5) (#x8FDAE6 #x86D7) (#x8FDAE7 #x86DA) (#x8FDAE8 #x86DC) (#x8FDAE9 #x86E0) (#x8FDAEA #x86E3) (#x8FDAEB #x86E5) (#x8FDAEC #x86E7) (#x8FDAED #x8688) (#x8FDAEE #x86FA) (#x8FDAEF #x86FC) (#x8FDAF0 #x86FD) (#x8FDAF1 #x8704) (#x8FDAF2 #x8705) (#x8FDAF3 #x8707) (#x8FDAF4 #x870B) (#x8FDAF5 #x870E) (#x8FDAF6 #x870F) (#x8FDAF7 #x8710) (#x8FDAF8 #x8713) (#x8FDAF9 #x8714) (#x8FDAFA #x8719) (#x8FDAFB #x871E) (#x8FDAFC #x871F) (#x8FDAFD #x8721) (#x8FDAFE #x8723) (#x8FDBA1 #x8728) (#x8FDBA2 #x872E) (#x8FDBA3 #x872F) (#x8FDBA4 #x8731) (#x8FDBA5 #x8732) (#x8FDBA6 #x8739) (#x8FDBA7 #x873A) (#x8FDBA8 #x873C) (#x8FDBA9 #x873D) (#x8FDBAA #x873E) (#x8FDBAB #x8740) (#x8FDBAC #x8743) (#x8FDBAD #x8745) (#x8FDBAE #x874D) (#x8FDBAF #x8758) (#x8FDBB0 #x875D) (#x8FDBB1 #x8761) (#x8FDBB2 #x8764) (#x8FDBB3 #x8765) (#x8FDBB4 #x876F) (#x8FDBB5 #x8771) (#x8FDBB6 #x8772) (#x8FDBB7 #x877B) (#x8FDBB8 #x8783) (#x8FDBB9 #x8784) (#x8FDBBA #x8785) (#x8FDBBB #x8786) (#x8FDBBC #x8787) (#x8FDBBD #x8788) (#x8FDBBE #x8789) (#x8FDBBF #x878B) (#x8FDBC0 #x878C) (#x8FDBC1 #x8790) (#x8FDBC2 #x8793) (#x8FDBC3 #x8795) (#x8FDBC4 #x8797) (#x8FDBC5 #x8798) (#x8FDBC6 #x8799) (#x8FDBC7 #x879E) (#x8FDBC8 #x87A0) (#x8FDBC9 #x87A3) (#x8FDBCA #x87A7) (#x8FDBCB #x87AC) (#x8FDBCC #x87AD) (#x8FDBCD #x87AE) (#x8FDBCE #x87B1) (#x8FDBCF #x87B5) (#x8FDBD0 #x87BE) (#x8FDBD1 #x87BF) (#x8FDBD2 #x87C1) (#x8FDBD3 #x87C8) (#x8FDBD4 #x87C9) (#x8FDBD5 #x87CA) (#x8FDBD6 #x87CE) (#x8FDBD7 #x87D5) (#x8FDBD8 #x87D6) (#x8FDBD9 #x87D9) (#x8FDBDA #x87DA) (#x8FDBDB #x87DC) (#x8FDBDC #x87DF) (#x8FDBDD #x87E2) (#x8FDBDE #x87E3) (#x8FDBDF #x87E4) (#x8FDBE0 #x87EA) (#x8FDBE1 #x87EB) (#x8FDBE2 #x87ED) (#x8FDBE3 #x87F1) (#x8FDBE4 #x87F3) (#x8FDBE5 #x87F8) (#x8FDBE6 #x87FA) (#x8FDBE7 #x87FF) (#x8FDBE8 #x8801) (#x8FDBE9 #x8803) (#x8FDBEA #x8806) (#x8FDBEB #x8809) (#x8FDBEC #x880A) (#x8FDBED #x880B) (#x8FDBEE #x8810) (#x8FDBEF #x8819) (#x8FDBF0 #x8812) (#x8FDBF1 #x8813) (#x8FDBF2 #x8814) (#x8FDBF3 #x8818) (#x8FDBF4 #x881A) (#x8FDBF5 #x881B) (#x8FDBF6 #x881C) (#x8FDBF7 #x881E) (#x8FDBF8 #x881F) (#x8FDBF9 #x8828) (#x8FDBFA #x882D) (#x8FDBFB #x882E) (#x8FDBFC #x8830) (#x8FDBFD #x8832) (#x8FDBFE #x8835) (#x8FDCA1 #x883A) (#x8FDCA2 #x883C) (#x8FDCA3 #x8841) (#x8FDCA4 #x8843) (#x8FDCA5 #x8845) (#x8FDCA6 #x8848) (#x8FDCA7 #x8849) (#x8FDCA8 #x884A) (#x8FDCA9 #x884B) (#x8FDCAA #x884E) (#x8FDCAB #x8851) (#x8FDCAC #x8855) (#x8FDCAD #x8856) (#x8FDCAE #x8858) (#x8FDCAF #x885A) (#x8FDCB0 #x885C) (#x8FDCB1 #x885F) (#x8FDCB2 #x8860) (#x8FDCB3 #x8864) (#x8FDCB4 #x8869) (#x8FDCB5 #x8871) (#x8FDCB6 #x8879) (#x8FDCB7 #x887B) (#x8FDCB8 #x8880) (#x8FDCB9 #x8898) (#x8FDCBA #x889A) (#x8FDCBB #x889B) (#x8FDCBC #x889C) (#x8FDCBD #x889F) (#x8FDCBE #x88A0) (#x8FDCBF #x88A8) (#x8FDCC0 #x88AA) (#x8FDCC1 #x88BA) (#x8FDCC2 #x88BD) (#x8FDCC3 #x88BE) (#x8FDCC4 #x88C0) (#x8FDCC5 #x88CA) (#x8FDCC6 #x88CB) (#x8FDCC7 #x88CC) (#x8FDCC8 #x88CD) (#x8FDCC9 #x88CE) (#x8FDCCA #x88D1) (#x8FDCCB #x88D2) (#x8FDCCC #x88D3) (#x8FDCCD #x88DB) (#x8FDCCE #x88DE) (#x8FDCCF #x88E7) (#x8FDCD0 #x88EF) (#x8FDCD1 #x88F0) (#x8FDCD2 #x88F1) (#x8FDCD3 #x88F5) (#x8FDCD4 #x88F7) (#x8FDCD5 #x8901) (#x8FDCD6 #x8906) (#x8FDCD7 #x890D) (#x8FDCD8 #x890E) (#x8FDCD9 #x890F) (#x8FDCDA #x8915) (#x8FDCDB #x8916) (#x8FDCDC #x8918) (#x8FDCDD #x8919) (#x8FDCDE #x891A) (#x8FDCDF #x891C) (#x8FDCE0 #x8920) (#x8FDCE1 #x8926) (#x8FDCE2 #x8927) (#x8FDCE3 #x8928) (#x8FDCE4 #x8930) (#x8FDCE5 #x8931) (#x8FDCE6 #x8932) (#x8FDCE7 #x8935) (#x8FDCE8 #x8939) (#x8FDCE9 #x893A) (#x8FDCEA #x893E) (#x8FDCEB #x8940) (#x8FDCEC #x8942) (#x8FDCED #x8945) (#x8FDCEE #x8946) (#x8FDCEF #x8949) (#x8FDCF0 #x894F) (#x8FDCF1 #x8952) (#x8FDCF2 #x8957) (#x8FDCF3 #x895A) (#x8FDCF4 #x895B) (#x8FDCF5 #x895C) (#x8FDCF6 #x8961) (#x8FDCF7 #x8962) (#x8FDCF8 #x8963) (#x8FDCF9 #x896B) (#x8FDCFA #x896E) (#x8FDCFB #x8970) (#x8FDCFC #x8973) (#x8FDCFD #x8975) (#x8FDCFE #x897A) (#x8FDDA1 #x897B) (#x8FDDA2 #x897C) (#x8FDDA3 #x897D) (#x8FDDA4 #x8989) (#x8FDDA5 #x898D) (#x8FDDA6 #x8990) (#x8FDDA7 #x8994) (#x8FDDA8 #x8995) (#x8FDDA9 #x899B) (#x8FDDAA #x899C) (#x8FDDAB #x899F) (#x8FDDAC #x89A0) (#x8FDDAD #x89A5) (#x8FDDAE #x89B0) (#x8FDDAF #x89B4) (#x8FDDB0 #x89B5) (#x8FDDB1 #x89B6) (#x8FDDB2 #x89B7) (#x8FDDB3 #x89BC) (#x8FDDB4 #x89D4) (#x8FDDB5 #x89D5) (#x8FDDB6 #x89D6) (#x8FDDB7 #x89D7) (#x8FDDB8 #x89D8) (#x8FDDB9 #x89E5) (#x8FDDBA #x89E9) (#x8FDDBB #x89EB) (#x8FDDBC #x89ED) (#x8FDDBD #x89F1) (#x8FDDBE #x89F3) (#x8FDDBF #x89F6) (#x8FDDC0 #x89F9) (#x8FDDC1 #x89FD) (#x8FDDC2 #x89FF) (#x8FDDC3 #x8A04) (#x8FDDC4 #x8A05) (#x8FDDC5 #x8A07) (#x8FDDC6 #x8A0F) (#x8FDDC7 #x8A11) (#x8FDDC8 #x8A12) (#x8FDDC9 #x8A14) (#x8FDDCA #x8A15) (#x8FDDCB #x8A1E) (#x8FDDCC #x8A20) (#x8FDDCD #x8A22) (#x8FDDCE #x8A24) (#x8FDDCF #x8A26) (#x8FDDD0 #x8A2B) (#x8FDDD1 #x8A2C) (#x8FDDD2 #x8A2F) (#x8FDDD3 #x8A35) (#x8FDDD4 #x8A37) (#x8FDDD5 #x8A3D) (#x8FDDD6 #x8A3E) (#x8FDDD7 #x8A40) (#x8FDDD8 #x8A43) (#x8FDDD9 #x8A45) (#x8FDDDA #x8A47) (#x8FDDDB #x8A49) (#x8FDDDC #x8A4D) (#x8FDDDD #x8A4E) (#x8FDDDE #x8A53) (#x8FDDDF #x8A56) (#x8FDDE0 #x8A57) (#x8FDDE1 #x8A58) (#x8FDDE2 #x8A5C) (#x8FDDE3 #x8A5D) (#x8FDDE4 #x8A61) (#x8FDDE5 #x8A65) (#x8FDDE6 #x8A67) (#x8FDDE7 #x8A75) (#x8FDDE8 #x8A76) (#x8FDDE9 #x8A77) (#x8FDDEA #x8A79) (#x8FDDEB #x8A7A) (#x8FDDEC #x8A7B) (#x8FDDED #x8A7E) (#x8FDDEE #x8A7F) (#x8FDDEF #x8A80) (#x8FDDF0 #x8A83) (#x8FDDF1 #x8A86) (#x8FDDF2 #x8A8B) (#x8FDDF3 #x8A8F) (#x8FDDF4 #x8A90) (#x8FDDF5 #x8A92) (#x8FDDF6 #x8A96) (#x8FDDF7 #x8A97) (#x8FDDF8 #x8A99) (#x8FDDF9 #x8A9F) (#x8FDDFA #x8AA7) (#x8FDDFB #x8AA9) (#x8FDDFC #x8AAE) (#x8FDDFD #x8AAF) (#x8FDDFE #x8AB3) (#x8FDEA1 #x8AB6) (#x8FDEA2 #x8AB7) (#x8FDEA3 #x8ABB) (#x8FDEA4 #x8ABE) (#x8FDEA5 #x8AC3) (#x8FDEA6 #x8AC6) (#x8FDEA7 #x8AC8) (#x8FDEA8 #x8AC9) (#x8FDEA9 #x8ACA) (#x8FDEAA #x8AD1) (#x8FDEAB #x8AD3) (#x8FDEAC #x8AD4) (#x8FDEAD #x8AD5) (#x8FDEAE #x8AD7) (#x8FDEAF #x8ADD) (#x8FDEB0 #x8ADF) (#x8FDEB1 #x8AEC) (#x8FDEB2 #x8AF0) (#x8FDEB3 #x8AF4) (#x8FDEB4 #x8AF5) (#x8FDEB5 #x8AF6) (#x8FDEB6 #x8AFC) (#x8FDEB7 #x8AFF) (#x8FDEB8 #x8B05) (#x8FDEB9 #x8B06) (#x8FDEBA #x8B0B) (#x8FDEBB #x8B11) (#x8FDEBC #x8B1C) (#x8FDEBD #x8B1E) (#x8FDEBE #x8B1F) (#x8FDEBF #x8B0A) (#x8FDEC0 #x8B2D) (#x8FDEC1 #x8B30) (#x8FDEC2 #x8B37) (#x8FDEC3 #x8B3C) (#x8FDEC4 #x8B42) (#x8FDEC5 #x8B43) (#x8FDEC6 #x8B44) (#x8FDEC7 #x8B45) (#x8FDEC8 #x8B46) (#x8FDEC9 #x8B48) (#x8FDECA #x8B52) (#x8FDECB #x8B53) (#x8FDECC #x8B54) (#x8FDECD #x8B59) (#x8FDECE #x8B4D) (#x8FDECF #x8B5E) (#x8FDED0 #x8B63) (#x8FDED1 #x8B6D) (#x8FDED2 #x8B76) (#x8FDED3 #x8B78) (#x8FDED4 #x8B79) (#x8FDED5 #x8B7C) (#x8FDED6 #x8B7E) (#x8FDED7 #x8B81) (#x8FDED8 #x8B84) (#x8FDED9 #x8B85) (#x8FDEDA #x8B8B) (#x8FDEDB #x8B8D) (#x8FDEDC #x8B8F) (#x8FDEDD #x8B94) (#x8FDEDE #x8B95) (#x8FDEDF #x8B9C) (#x8FDEE0 #x8B9E) (#x8FDEE1 #x8B9F) (#x8FDEE2 #x8C38) (#x8FDEE3 #x8C39) (#x8FDEE4 #x8C3D) (#x8FDEE5 #x8C3E) (#x8FDEE6 #x8C45) (#x8FDEE7 #x8C47) (#x8FDEE8 #x8C49) (#x8FDEE9 #x8C4B) (#x8FDEEA #x8C4F) (#x8FDEEB #x8C51) (#x8FDEEC #x8C53) (#x8FDEED #x8C54) (#x8FDEEE #x8C57) (#x8FDEEF #x8C58) (#x8FDEF0 #x8C5B) (#x8FDEF1 #x8C5D) (#x8FDEF2 #x8C59) (#x8FDEF3 #x8C63) (#x8FDEF4 #x8C64) (#x8FDEF5 #x8C66) (#x8FDEF6 #x8C68) (#x8FDEF7 #x8C69) (#x8FDEF8 #x8C6D) (#x8FDEF9 #x8C73) (#x8FDEFA #x8C75) (#x8FDEFB #x8C76) (#x8FDEFC #x8C7B) (#x8FDEFD #x8C7E) (#x8FDEFE #x8C86) (#x8FDFA1 #x8C87) (#x8FDFA2 #x8C8B) (#x8FDFA3 #x8C90) (#x8FDFA4 #x8C92) (#x8FDFA5 #x8C93) (#x8FDFA6 #x8C99) (#x8FDFA7 #x8C9B) (#x8FDFA8 #x8C9C) (#x8FDFA9 #x8CA4) (#x8FDFAA #x8CB9) (#x8FDFAB #x8CBA) (#x8FDFAC #x8CC5) (#x8FDFAD #x8CC6) (#x8FDFAE #x8CC9) (#x8FDFAF #x8CCB) (#x8FDFB0 #x8CCF) (#x8FDFB1 #x8CD6) (#x8FDFB2 #x8CD5) (#x8FDFB3 #x8CD9) (#x8FDFB4 #x8CDD) (#x8FDFB5 #x8CE1) (#x8FDFB6 #x8CE8) (#x8FDFB7 #x8CEC) (#x8FDFB8 #x8CEF) (#x8FDFB9 #x8CF0) (#x8FDFBA #x8CF2) (#x8FDFBB #x8CF5) (#x8FDFBC #x8CF7) (#x8FDFBD #x8CF8) (#x8FDFBE #x8CFE) (#x8FDFBF #x8CFF) (#x8FDFC0 #x8D01) (#x8FDFC1 #x8D03) (#x8FDFC2 #x8D09) (#x8FDFC3 #x8D12) (#x8FDFC4 #x8D17) (#x8FDFC5 #x8D1B) (#x8FDFC6 #x8D65) (#x8FDFC7 #x8D69) (#x8FDFC8 #x8D6C) (#x8FDFC9 #x8D6E) (#x8FDFCA #x8D7F) (#x8FDFCB #x8D82) (#x8FDFCC #x8D84) (#x8FDFCD #x8D88) (#x8FDFCE #x8D8D) (#x8FDFCF #x8D90) (#x8FDFD0 #x8D91) (#x8FDFD1 #x8D95) (#x8FDFD2 #x8D9E) (#x8FDFD3 #x8D9F) (#x8FDFD4 #x8DA0) (#x8FDFD5 #x8DA6) (#x8FDFD6 #x8DAB) (#x8FDFD7 #x8DAC) (#x8FDFD8 #x8DAF) (#x8FDFD9 #x8DB2) (#x8FDFDA #x8DB5) (#x8FDFDB #x8DB7) (#x8FDFDC #x8DB9) (#x8FDFDD #x8DBB) (#x8FDFDE #x8DC0) (#x8FDFDF #x8DC5) (#x8FDFE0 #x8DC6) (#x8FDFE1 #x8DC7) (#x8FDFE2 #x8DC8) (#x8FDFE3 #x8DCA) (#x8FDFE4 #x8DCE) (#x8FDFE5 #x8DD1) (#x8FDFE6 #x8DD4) (#x8FDFE7 #x8DD5) (#x8FDFE8 #x8DD7) (#x8FDFE9 #x8DD9) (#x8FDFEA #x8DE4) (#x8FDFEB #x8DE5) (#x8FDFEC #x8DE7) (#x8FDFED #x8DEC) (#x8FDFEE #x8DF0) (#x8FDFEF #x8DBC) (#x8FDFF0 #x8DF1) (#x8FDFF1 #x8DF2) (#x8FDFF2 #x8DF4) (#x8FDFF3 #x8DFD) (#x8FDFF4 #x8E01) (#x8FDFF5 #x8E04) (#x8FDFF6 #x8E05) (#x8FDFF7 #x8E06) (#x8FDFF8 #x8E0B) (#x8FDFF9 #x8E11) (#x8FDFFA #x8E14) (#x8FDFFB #x8E16) (#x8FDFFC #x8E20) (#x8FDFFD #x8E21) (#x8FDFFE #x8E22) (#x8FE0A1 #x8E23) (#x8FE0A2 #x8E26) (#x8FE0A3 #x8E27) (#x8FE0A4 #x8E31) (#x8FE0A5 #x8E33) (#x8FE0A6 #x8E36) (#x8FE0A7 #x8E37) (#x8FE0A8 #x8E38) (#x8FE0A9 #x8E39) (#x8FE0AA #x8E3D) (#x8FE0AB #x8E40) (#x8FE0AC #x8E41) (#x8FE0AD #x8E4B) (#x8FE0AE #x8E4D) (#x8FE0AF #x8E4E) (#x8FE0B0 #x8E4F) (#x8FE0B1 #x8E54) (#x8FE0B2 #x8E5B) (#x8FE0B3 #x8E5C) (#x8FE0B4 #x8E5D) (#x8FE0B5 #x8E5E) (#x8FE0B6 #x8E61) (#x8FE0B7 #x8E62) (#x8FE0B8 #x8E69) (#x8FE0B9 #x8E6C) (#x8FE0BA #x8E6D) (#x8FE0BB #x8E6F) (#x8FE0BC #x8E70) (#x8FE0BD #x8E71) (#x8FE0BE #x8E79) (#x8FE0BF #x8E7A) (#x8FE0C0 #x8E7B) (#x8FE0C1 #x8E82) (#x8FE0C2 #x8E83) (#x8FE0C3 #x8E89) (#x8FE0C4 #x8E90) (#x8FE0C5 #x8E92) (#x8FE0C6 #x8E95) (#x8FE0C7 #x8E9A) (#x8FE0C8 #x8E9B) (#x8FE0C9 #x8E9D) (#x8FE0CA #x8E9E) (#x8FE0CB #x8EA2) (#x8FE0CC #x8EA7) (#x8FE0CD #x8EA9) (#x8FE0CE #x8EAD) (#x8FE0CF #x8EAE) (#x8FE0D0 #x8EB3) (#x8FE0D1 #x8EB5) (#x8FE0D2 #x8EBA) (#x8FE0D3 #x8EBB) (#x8FE0D4 #x8EC0) (#x8FE0D5 #x8EC1) (#x8FE0D6 #x8EC3) (#x8FE0D7 #x8EC4) (#x8FE0D8 #x8EC7) (#x8FE0D9 #x8ECF) (#x8FE0DA #x8ED1) (#x8FE0DB #x8ED4) (#x8FE0DC #x8EDC) (#x8FE0DD #x8EE8) (#x8FE0DE #x8EEE) (#x8FE0DF #x8EF0) (#x8FE0E0 #x8EF1) (#x8FE0E1 #x8EF7) (#x8FE0E2 #x8EF9) (#x8FE0E3 #x8EFA) (#x8FE0E4 #x8EED) (#x8FE0E5 #x8F00) (#x8FE0E6 #x8F02) (#x8FE0E7 #x8F07) (#x8FE0E8 #x8F08) (#x8FE0E9 #x8F0F) (#x8FE0EA #x8F10) (#x8FE0EB #x8F16) (#x8FE0EC #x8F17) (#x8FE0ED #x8F18) (#x8FE0EE #x8F1E) (#x8FE0EF #x8F20) (#x8FE0F0 #x8F21) (#x8FE0F1 #x8F23) (#x8FE0F2 #x8F25) (#x8FE0F3 #x8F27) (#x8FE0F4 #x8F28) (#x8FE0F5 #x8F2C) (#x8FE0F6 #x8F2D) (#x8FE0F7 #x8F2E) (#x8FE0F8 #x8F34) (#x8FE0F9 #x8F35) (#x8FE0FA #x8F36) (#x8FE0FB #x8F37) (#x8FE0FC #x8F3A) (#x8FE0FD #x8F40) (#x8FE0FE #x8F41) (#x8FE1A1 #x8F43) (#x8FE1A2 #x8F47) (#x8FE1A3 #x8F4F) (#x8FE1A4 #x8F51) (#x8FE1A5 #x8F52) (#x8FE1A6 #x8F53) (#x8FE1A7 #x8F54) (#x8FE1A8 #x8F55) (#x8FE1A9 #x8F58) (#x8FE1AA #x8F5D) (#x8FE1AB #x8F5E) (#x8FE1AC #x8F65) (#x8FE1AD #x8F9D) (#x8FE1AE #x8FA0) (#x8FE1AF #x8FA1) (#x8FE1B0 #x8FA4) (#x8FE1B1 #x8FA5) (#x8FE1B2 #x8FA6) (#x8FE1B3 #x8FB5) (#x8FE1B4 #x8FB6) (#x8FE1B5 #x8FB8) (#x8FE1B6 #x8FBE) (#x8FE1B7 #x8FC0) (#x8FE1B8 #x8FC1) (#x8FE1B9 #x8FC6) (#x8FE1BA #x8FCA) (#x8FE1BB #x8FCB) (#x8FE1BC #x8FCD) (#x8FE1BD #x8FD0) (#x8FE1BE #x8FD2) (#x8FE1BF #x8FD3) (#x8FE1C0 #x8FD5) (#x8FE1C1 #x8FE0) (#x8FE1C2 #x8FE3) (#x8FE1C3 #x8FE4) (#x8FE1C4 #x8FE8) (#x8FE1C5 #x8FEE) (#x8FE1C6 #x8FF1) (#x8FE1C7 #x8FF5) (#x8FE1C8 #x8FF6) (#x8FE1C9 #x8FFB) (#x8FE1CA #x8FFE) (#x8FE1CB #x9002) (#x8FE1CC #x9004) (#x8FE1CD #x9008) (#x8FE1CE #x900C) (#x8FE1CF #x9018) (#x8FE1D0 #x901B) (#x8FE1D1 #x9028) (#x8FE1D2 #x9029) (#x8FE1D3 #x902F) (#x8FE1D4 #x902A) (#x8FE1D5 #x902C) (#x8FE1D6 #x902D) (#x8FE1D7 #x9033) (#x8FE1D8 #x9034) (#x8FE1D9 #x9037) (#x8FE1DA #x903F) (#x8FE1DB #x9043) (#x8FE1DC #x9044) (#x8FE1DD #x904C) (#x8FE1DE #x905B) (#x8FE1DF #x905D) (#x8FE1E0 #x9062) (#x8FE1E1 #x9066) (#x8FE1E2 #x9067) (#x8FE1E3 #x906C) (#x8FE1E4 #x9070) (#x8FE1E5 #x9074) (#x8FE1E6 #x9079) (#x8FE1E7 #x9085) (#x8FE1E8 #x9088) (#x8FE1E9 #x908B) (#x8FE1EA #x908C) (#x8FE1EB #x908E) (#x8FE1EC #x9090) (#x8FE1ED #x9095) (#x8FE1EE #x9097) (#x8FE1EF #x9098) (#x8FE1F0 #x9099) (#x8FE1F1 #x909B) (#x8FE1F2 #x90A0) (#x8FE1F3 #x90A1) (#x8FE1F4 #x90A2) (#x8FE1F5 #x90A5) (#x8FE1F6 #x90B0) (#x8FE1F7 #x90B2) (#x8FE1F8 #x90B3) (#x8FE1F9 #x90B4) (#x8FE1FA #x90B6) (#x8FE1FB #x90BD) (#x8FE1FC #x90CC) (#x8FE1FD #x90BE) (#x8FE1FE #x90C3) (#x8FE2A1 #x90C4) (#x8FE2A2 #x90C5) (#x8FE2A3 #x90C7) (#x8FE2A4 #x90C8) (#x8FE2A5 #x90D5) (#x8FE2A6 #x90D7) (#x8FE2A7 #x90D8) (#x8FE2A8 #x90D9) (#x8FE2A9 #x90DC) (#x8FE2AA #x90DD) (#x8FE2AB #x90DF) (#x8FE2AC #x90E5) (#x8FE2AD #x90D2) (#x8FE2AE #x90F6) (#x8FE2AF #x90EB) (#x8FE2B0 #x90EF) (#x8FE2B1 #x90F0) (#x8FE2B2 #x90F4) (#x8FE2B3 #x90FE) (#x8FE2B4 #x90FF) (#x8FE2B5 #x9100) (#x8FE2B6 #x9104) (#x8FE2B7 #x9105) (#x8FE2B8 #x9106) (#x8FE2B9 #x9108) (#x8FE2BA #x910D) (#x8FE2BB #x9110) (#x8FE2BC #x9114) (#x8FE2BD #x9116) (#x8FE2BE #x9117) (#x8FE2BF #x9118) (#x8FE2C0 #x911A) (#x8FE2C1 #x911C) (#x8FE2C2 #x911E) (#x8FE2C3 #x9120) (#x8FE2C4 #x9125) (#x8FE2C5 #x9122) (#x8FE2C6 #x9123) (#x8FE2C7 #x9127) (#x8FE2C8 #x9129) (#x8FE2C9 #x912E) (#x8FE2CA #x912F) (#x8FE2CB #x9131) (#x8FE2CC #x9134) (#x8FE2CD #x9136) (#x8FE2CE #x9137) (#x8FE2CF #x9139) (#x8FE2D0 #x913A) (#x8FE2D1 #x913C) (#x8FE2D2 #x913D) (#x8FE2D3 #x9143) (#x8FE2D4 #x9147) (#x8FE2D5 #x9148) (#x8FE2D6 #x914F) (#x8FE2D7 #x9153) (#x8FE2D8 #x9157) (#x8FE2D9 #x9159) (#x8FE2DA #x915A) (#x8FE2DB #x915B) (#x8FE2DC #x9161) (#x8FE2DD #x9164) (#x8FE2DE #x9167) (#x8FE2DF #x916D) (#x8FE2E0 #x9174) (#x8FE2E1 #x9179) (#x8FE2E2 #x917A) (#x8FE2E3 #x917B) (#x8FE2E4 #x9181) (#x8FE2E5 #x9183) (#x8FE2E6 #x9185) (#x8FE2E7 #x9186) (#x8FE2E8 #x918A) (#x8FE2E9 #x918E) (#x8FE2EA #x9191) (#x8FE2EB #x9193) (#x8FE2EC #x9194) (#x8FE2ED #x9195) (#x8FE2EE #x9198) (#x8FE2EF #x919E) (#x8FE2F0 #x91A1) (#x8FE2F1 #x91A6) (#x8FE2F2 #x91A8) (#x8FE2F3 #x91AC) (#x8FE2F4 #x91AD) (#x8FE2F5 #x91AE) (#x8FE2F6 #x91B0) (#x8FE2F7 #x91B1) (#x8FE2F8 #x91B2) (#x8FE2F9 #x91B3) (#x8FE2FA #x91B6) (#x8FE2FB #x91BB) (#x8FE2FC #x91BC) (#x8FE2FD #x91BD) (#x8FE2FE #x91BF) (#x8FE3A1 #x91C2) (#x8FE3A2 #x91C3) (#x8FE3A3 #x91C5) (#x8FE3A4 #x91D3) (#x8FE3A5 #x91D4) (#x8FE3A6 #x91D7) (#x8FE3A7 #x91D9) (#x8FE3A8 #x91DA) (#x8FE3A9 #x91DE) (#x8FE3AA #x91E4) (#x8FE3AB #x91E5) (#x8FE3AC #x91E9) (#x8FE3AD #x91EA) (#x8FE3AE #x91EC) (#x8FE3AF #x91ED) (#x8FE3B0 #x91EE) (#x8FE3B1 #x91EF) (#x8FE3B2 #x91F0) (#x8FE3B3 #x91F1) (#x8FE3B4 #x91F7) (#x8FE3B5 #x91F9) (#x8FE3B6 #x91FB) (#x8FE3B7 #x91FD) (#x8FE3B8 #x9200) (#x8FE3B9 #x9201) (#x8FE3BA #x9204) (#x8FE3BB #x9205) (#x8FE3BC #x9206) (#x8FE3BD #x9207) (#x8FE3BE #x9209) (#x8FE3BF #x920A) (#x8FE3C0 #x920C) (#x8FE3C1 #x9210) (#x8FE3C2 #x9212) (#x8FE3C3 #x9213) (#x8FE3C4 #x9216) (#x8FE3C5 #x9218) (#x8FE3C6 #x921C) (#x8FE3C7 #x921D) (#x8FE3C8 #x9223) (#x8FE3C9 #x9224) (#x8FE3CA #x9225) (#x8FE3CB #x9226) (#x8FE3CC #x9228) (#x8FE3CD #x922E) (#x8FE3CE #x922F) (#x8FE3CF #x9230) (#x8FE3D0 #x9233) (#x8FE3D1 #x9235) (#x8FE3D2 #x9236) (#x8FE3D3 #x9238) (#x8FE3D4 #x9239) (#x8FE3D5 #x923A) (#x8FE3D6 #x923C) (#x8FE3D7 #x923E) (#x8FE3D8 #x9240) (#x8FE3D9 #x9242) (#x8FE3DA #x9243) (#x8FE3DB #x9246) (#x8FE3DC #x9247) (#x8FE3DD #x924A) (#x8FE3DE #x924D) (#x8FE3DF #x924E) (#x8FE3E0 #x924F) (#x8FE3E1 #x9251) (#x8FE3E2 #x9258) (#x8FE3E3 #x9259) (#x8FE3E4 #x925C) (#x8FE3E5 #x925D) (#x8FE3E6 #x9260) (#x8FE3E7 #x9261) (#x8FE3E8 #x9265) (#x8FE3E9 #x9267) (#x8FE3EA #x9268) (#x8FE3EB #x9269) (#x8FE3EC #x926E) (#x8FE3ED #x926F) (#x8FE3EE #x9270) (#x8FE3EF #x9275) (#x8FE3F0 #x9276) (#x8FE3F1 #x9277) (#x8FE3F2 #x9278) (#x8FE3F3 #x9279) (#x8FE3F4 #x927B) (#x8FE3F5 #x927C) (#x8FE3F6 #x927D) (#x8FE3F7 #x927F) (#x8FE3F8 #x9288) (#x8FE3F9 #x9289) (#x8FE3FA #x928A) (#x8FE3FB #x928D) (#x8FE3FC #x928E) (#x8FE3FD #x9292) (#x8FE3FE #x9297) (#x8FE4A1 #x9299) (#x8FE4A2 #x929F) (#x8FE4A3 #x92A0) (#x8FE4A4 #x92A4) (#x8FE4A5 #x92A5) (#x8FE4A6 #x92A7) (#x8FE4A7 #x92A8) (#x8FE4A8 #x92AB) (#x8FE4A9 #x92AF) (#x8FE4AA #x92B2) (#x8FE4AB #x92B6) (#x8FE4AC #x92B8) (#x8FE4AD #x92BA) (#x8FE4AE #x92BB) (#x8FE4AF #x92BC) (#x8FE4B0 #x92BD) (#x8FE4B1 #x92BF) (#x8FE4B2 #x92C0) (#x8FE4B3 #x92C1) (#x8FE4B4 #x92C2) (#x8FE4B5 #x92C3) (#x8FE4B6 #x92C5) (#x8FE4B7 #x92C6) (#x8FE4B8 #x92C7) (#x8FE4B9 #x92C8) (#x8FE4BA #x92CB) (#x8FE4BB #x92CC) (#x8FE4BC #x92CD) (#x8FE4BD #x92CE) (#x8FE4BE #x92D0) (#x8FE4BF #x92D3) (#x8FE4C0 #x92D5) (#x8FE4C1 #x92D7) (#x8FE4C2 #x92D8) (#x8FE4C3 #x92D9) (#x8FE4C4 #x92DC) (#x8FE4C5 #x92DD) (#x8FE4C6 #x92DF) (#x8FE4C7 #x92E0) (#x8FE4C8 #x92E1) (#x8FE4C9 #x92E3) (#x8FE4CA #x92E5) (#x8FE4CB #x92E7) (#x8FE4CC #x92E8) (#x8FE4CD #x92EC) (#x8FE4CE #x92EE) (#x8FE4CF #x92F0) (#x8FE4D0 #x92F9) (#x8FE4D1 #x92FB) (#x8FE4D2 #x92FF) (#x8FE4D3 #x9300) (#x8FE4D4 #x9302) (#x8FE4D5 #x9308) (#x8FE4D6 #x930D) (#x8FE4D7 #x9311) (#x8FE4D8 #x9314) (#x8FE4D9 #x9315) (#x8FE4DA #x931C) (#x8FE4DB #x931D) (#x8FE4DC #x931E) (#x8FE4DD #x931F) (#x8FE4DE #x9321) (#x8FE4DF #x9324) (#x8FE4E0 #x9325) (#x8FE4E1 #x9327) (#x8FE4E2 #x9329) (#x8FE4E3 #x932A) (#x8FE4E4 #x9333) (#x8FE4E5 #x9334) (#x8FE4E6 #x9336) (#x8FE4E7 #x9337) (#x8FE4E8 #x9347) (#x8FE4E9 #x9348) (#x8FE4EA #x9349) (#x8FE4EB #x9350) (#x8FE4EC #x9351) (#x8FE4ED #x9352) (#x8FE4EE #x9355) (#x8FE4EF #x9357) (#x8FE4F0 #x9358) (#x8FE4F1 #x935A) (#x8FE4F2 #x935E) (#x8FE4F3 #x9364) (#x8FE4F4 #x9365) (#x8FE4F5 #x9367) (#x8FE4F6 #x9369) (#x8FE4F7 #x936A) (#x8FE4F8 #x936D) (#x8FE4F9 #x936F) (#x8FE4FA #x9370) (#x8FE4FB #x9371) (#x8FE4FC #x9373) (#x8FE4FD #x9374) (#x8FE4FE #x9376) (#x8FE5A1 #x937A) (#x8FE5A2 #x937D) (#x8FE5A3 #x937F) (#x8FE5A4 #x9380) (#x8FE5A5 #x9381) (#x8FE5A6 #x9382) (#x8FE5A7 #x9388) (#x8FE5A8 #x938A) (#x8FE5A9 #x938B) (#x8FE5AA #x938D) (#x8FE5AB #x938F) (#x8FE5AC #x9392) (#x8FE5AD #x9395) (#x8FE5AE #x9398) (#x8FE5AF #x939B) (#x8FE5B0 #x939E) (#x8FE5B1 #x93A1) (#x8FE5B2 #x93A3) (#x8FE5B3 #x93A4) (#x8FE5B4 #x93A6) (#x8FE5B5 #x93A8) (#x8FE5B6 #x93AB) (#x8FE5B7 #x93B4) (#x8FE5B8 #x93B5) (#x8FE5B9 #x93B6) (#x8FE5BA #x93BA) (#x8FE5BB #x93A9) (#x8FE5BC #x93C1) (#x8FE5BD #x93C4) (#x8FE5BE #x93C5) (#x8FE5BF #x93C6) (#x8FE5C0 #x93C7) (#x8FE5C1 #x93C9) (#x8FE5C2 #x93CA) (#x8FE5C3 #x93CB) (#x8FE5C4 #x93CC) (#x8FE5C5 #x93CD) (#x8FE5C6 #x93D3) (#x8FE5C7 #x93D9) (#x8FE5C8 #x93DC) (#x8FE5C9 #x93DE) (#x8FE5CA #x93DF) (#x8FE5CB #x93E2) (#x8FE5CC #x93E6) (#x8FE5CD #x93E7) (#x8FE5CE #x93F9) (#x8FE5CF #x93F7) (#x8FE5D0 #x93F8) (#x8FE5D1 #x93FA) (#x8FE5D2 #x93FB) (#x8FE5D3 #x93FD) (#x8FE5D4 #x9401) (#x8FE5D5 #x9402) (#x8FE5D6 #x9404) (#x8FE5D7 #x9408) (#x8FE5D8 #x9409) (#x8FE5D9 #x940D) (#x8FE5DA #x940E) (#x8FE5DB #x940F) (#x8FE5DC #x9415) (#x8FE5DD #x9416) (#x8FE5DE #x9417) (#x8FE5DF #x941F) (#x8FE5E0 #x942E) (#x8FE5E1 #x942F) (#x8FE5E2 #x9431) (#x8FE5E3 #x9432) (#x8FE5E4 #x9433) (#x8FE5E5 #x9434) (#x8FE5E6 #x943B) (#x8FE5E7 #x943F) (#x8FE5E8 #x943D) (#x8FE5E9 #x9443) (#x8FE5EA #x9445) (#x8FE5EB #x9448) (#x8FE5EC #x944A) (#x8FE5ED #x944C) (#x8FE5EE #x9455) (#x8FE5EF #x9459) (#x8FE5F0 #x945C) (#x8FE5F1 #x945F) (#x8FE5F2 #x9461) (#x8FE5F3 #x9463) (#x8FE5F4 #x9468) (#x8FE5F5 #x946B) (#x8FE5F6 #x946D) (#x8FE5F7 #x946E) (#x8FE5F8 #x946F) (#x8FE5F9 #x9471) (#x8FE5FA #x9472) (#x8FE5FB #x9484) (#x8FE5FC #x9483) (#x8FE5FD #x9578) (#x8FE5FE #x9579) (#x8FE6A1 #x957E) (#x8FE6A2 #x9584) (#x8FE6A3 #x9588) (#x8FE6A4 #x958C) (#x8FE6A5 #x958D) (#x8FE6A6 #x958E) (#x8FE6A7 #x959D) (#x8FE6A8 #x959E) (#x8FE6A9 #x959F) (#x8FE6AA #x95A1) (#x8FE6AB #x95A6) (#x8FE6AC #x95A9) (#x8FE6AD #x95AB) (#x8FE6AE #x95AC) (#x8FE6AF #x95B4) (#x8FE6B0 #x95B6) (#x8FE6B1 #x95BA) (#x8FE6B2 #x95BD) (#x8FE6B3 #x95BF) (#x8FE6B4 #x95C6) (#x8FE6B5 #x95C8) (#x8FE6B6 #x95C9) (#x8FE6B7 #x95CB) (#x8FE6B8 #x95D0) (#x8FE6B9 #x95D1) (#x8FE6BA #x95D2) (#x8FE6BB #x95D3) (#x8FE6BC #x95D9) (#x8FE6BD #x95DA) (#x8FE6BE #x95DD) (#x8FE6BF #x95DE) (#x8FE6C0 #x95DF) (#x8FE6C1 #x95E0) (#x8FE6C2 #x95E4) (#x8FE6C3 #x95E6) (#x8FE6C4 #x961D) (#x8FE6C5 #x961E) (#x8FE6C6 #x9622) (#x8FE6C7 #x9624) (#x8FE6C8 #x9625) (#x8FE6C9 #x9626) (#x8FE6CA #x962C) (#x8FE6CB #x9631) (#x8FE6CC #x9633) (#x8FE6CD #x9637) (#x8FE6CE #x9638) (#x8FE6CF #x9639) (#x8FE6D0 #x963A) (#x8FE6D1 #x963C) (#x8FE6D2 #x963D) (#x8FE6D3 #x9641) (#x8FE6D4 #x9652) (#x8FE6D5 #x9654) (#x8FE6D6 #x9656) (#x8FE6D7 #x9657) (#x8FE6D8 #x9658) (#x8FE6D9 #x9661) (#x8FE6DA #x966E) (#x8FE6DB #x9674) (#x8FE6DC #x967B) (#x8FE6DD #x967C) (#x8FE6DE #x967E) (#x8FE6DF #x967F) (#x8FE6E0 #x9681) (#x8FE6E1 #x9682) (#x8FE6E2 #x9683) (#x8FE6E3 #x9684) (#x8FE6E4 #x9689) (#x8FE6E5 #x9691) (#x8FE6E6 #x9696) (#x8FE6E7 #x969A) (#x8FE6E8 #x969D) (#x8FE6E9 #x969F) (#x8FE6EA #x96A4) (#x8FE6EB #x96A5) (#x8FE6EC #x96A6) (#x8FE6ED #x96A9) (#x8FE6EE #x96AE) (#x8FE6EF #x96AF) (#x8FE6F0 #x96B3) (#x8FE6F1 #x96BA) (#x8FE6F2 #x96CA) (#x8FE6F3 #x96D2) (#x8FE6F4 #x5DB2) (#x8FE6F5 #x96D8) (#x8FE6F6 #x96DA) (#x8FE6F7 #x96DD) (#x8FE6F8 #x96DE) (#x8FE6F9 #x96DF) (#x8FE6FA #x96E9) (#x8FE6FB #x96EF) (#x8FE6FC #x96F1) (#x8FE6FD #x96FA) (#x8FE6FE #x9702) (#x8FE7A1 #x9703) (#x8FE7A2 #x9705) (#x8FE7A3 #x9709) (#x8FE7A4 #x971A) (#x8FE7A5 #x971B) (#x8FE7A6 #x971D) (#x8FE7A7 #x9721) (#x8FE7A8 #x9722) (#x8FE7A9 #x9723) (#x8FE7AA #x9728) (#x8FE7AB #x9731) (#x8FE7AC #x9733) (#x8FE7AD #x9741) (#x8FE7AE #x9743) (#x8FE7AF #x974A) (#x8FE7B0 #x974E) (#x8FE7B1 #x974F) (#x8FE7B2 #x9755) (#x8FE7B3 #x9757) (#x8FE7B4 #x9758) (#x8FE7B5 #x975A) (#x8FE7B6 #x975B) (#x8FE7B7 #x9763) (#x8FE7B8 #x9767) (#x8FE7B9 #x976A) (#x8FE7BA #x976E) (#x8FE7BB #x9773) (#x8FE7BC #x9776) (#x8FE7BD #x9777) (#x8FE7BE #x9778) (#x8FE7BF #x977B) (#x8FE7C0 #x977D) (#x8FE7C1 #x977F) (#x8FE7C2 #x9780) (#x8FE7C3 #x9789) (#x8FE7C4 #x9795) (#x8FE7C5 #x9796) (#x8FE7C6 #x9797) (#x8FE7C7 #x9799) (#x8FE7C8 #x979A) (#x8FE7C9 #x979E) (#x8FE7CA #x979F) (#x8FE7CB #x97A2) (#x8FE7CC #x97AC) (#x8FE7CD #x97AE) (#x8FE7CE #x97B1) (#x8FE7CF #x97B2) (#x8FE7D0 #x97B5) (#x8FE7D1 #x97B6) (#x8FE7D2 #x97B8) (#x8FE7D3 #x97B9) (#x8FE7D4 #x97BA) (#x8FE7D5 #x97BC) (#x8FE7D6 #x97BE) (#x8FE7D7 #x97BF) (#x8FE7D8 #x97C1) (#x8FE7D9 #x97C4) (#x8FE7DA #x97C5) (#x8FE7DB #x97C7) (#x8FE7DC #x97C9) (#x8FE7DD #x97CA) (#x8FE7DE #x97CC) (#x8FE7DF #x97CD) (#x8FE7E0 #x97CE) (#x8FE7E1 #x97D0) (#x8FE7E2 #x97D1) (#x8FE7E3 #x97D4) (#x8FE7E4 #x97D7) (#x8FE7E5 #x97D8) (#x8FE7E6 #x97D9) (#x8FE7E7 #x97DD) (#x8FE7E8 #x97DE) (#x8FE7E9 #x97E0) (#x8FE7EA #x97DB) (#x8FE7EB #x97E1) (#x8FE7EC #x97E4) (#x8FE7ED #x97EF) (#x8FE7EE #x97F1) (#x8FE7EF #x97F4) (#x8FE7F0 #x97F7) (#x8FE7F1 #x97F8) (#x8FE7F2 #x97FA) (#x8FE7F3 #x9807) (#x8FE7F4 #x980A) (#x8FE7F5 #x9819) (#x8FE7F6 #x980D) (#x8FE7F7 #x980E) (#x8FE7F8 #x9814) (#x8FE7F9 #x9816) (#x8FE7FA #x981C) (#x8FE7FB #x981E) (#x8FE7FC #x9820) (#x8FE7FD #x9823) (#x8FE7FE #x9826) (#x8FE8A1 #x982B) (#x8FE8A2 #x982E) (#x8FE8A3 #x982F) (#x8FE8A4 #x9830) (#x8FE8A5 #x9832) (#x8FE8A6 #x9833) (#x8FE8A7 #x9835) (#x8FE8A8 #x9825) (#x8FE8A9 #x983E) (#x8FE8AA #x9844) (#x8FE8AB #x9847) (#x8FE8AC #x984A) (#x8FE8AD #x9851) (#x8FE8AE #x9852) (#x8FE8AF #x9853) (#x8FE8B0 #x9856) (#x8FE8B1 #x9857) (#x8FE8B2 #x9859) (#x8FE8B3 #x985A) (#x8FE8B4 #x9862) (#x8FE8B5 #x9863) (#x8FE8B6 #x9865) (#x8FE8B7 #x9866) (#x8FE8B8 #x986A) (#x8FE8B9 #x986C) (#x8FE8BA #x98AB) (#x8FE8BB #x98AD) (#x8FE8BC #x98AE) (#x8FE8BD #x98B0) (#x8FE8BE #x98B4) (#x8FE8BF #x98B7) (#x8FE8C0 #x98B8) (#x8FE8C1 #x98BA) (#x8FE8C2 #x98BB) (#x8FE8C3 #x98BF) (#x8FE8C4 #x98C2) (#x8FE8C5 #x98C5) (#x8FE8C6 #x98C8) (#x8FE8C7 #x98CC) (#x8FE8C8 #x98E1) (#x8FE8C9 #x98E3) (#x8FE8CA #x98E5) (#x8FE8CB #x98E6) (#x8FE8CC #x98E7) (#x8FE8CD #x98EA) (#x8FE8CE #x98F3) (#x8FE8CF #x98F6) (#x8FE8D0 #x9902) (#x8FE8D1 #x9907) (#x8FE8D2 #x9908) (#x8FE8D3 #x9911) (#x8FE8D4 #x9915) (#x8FE8D5 #x9916) (#x8FE8D6 #x9917) (#x8FE8D7 #x991A) (#x8FE8D8 #x991B) (#x8FE8D9 #x991C) (#x8FE8DA #x991F) (#x8FE8DB #x9922) (#x8FE8DC #x9926) (#x8FE8DD #x9927) (#x8FE8DE #x992B) (#x8FE8DF #x9931) (#x8FE8E0 #x9932) (#x8FE8E1 #x9933) (#x8FE8E2 #x9934) (#x8FE8E3 #x9935) (#x8FE8E4 #x9939) (#x8FE8E5 #x993A) (#x8FE8E6 #x993B) (#x8FE8E7 #x993C) (#x8FE8E8 #x9940) (#x8FE8E9 #x9941) (#x8FE8EA #x9946) (#x8FE8EB #x9947) (#x8FE8EC #x9948) (#x8FE8ED #x994D) (#x8FE8EE #x994E) (#x8FE8EF #x9954) (#x8FE8F0 #x9958) (#x8FE8F1 #x9959) (#x8FE8F2 #x995B) (#x8FE8F3 #x995C) (#x8FE8F4 #x995E) (#x8FE8F5 #x995F) (#x8FE8F6 #x9960) (#x8FE8F7 #x999B) (#x8FE8F8 #x999D) (#x8FE8F9 #x999F) (#x8FE8FA #x99A6) (#x8FE8FB #x99B0) (#x8FE8FC #x99B1) (#x8FE8FD #x99B2) (#x8FE8FE #x99B5) (#x8FE9A1 #x99B9) (#x8FE9A2 #x99BA) (#x8FE9A3 #x99BD) (#x8FE9A4 #x99BF) (#x8FE9A5 #x99C3) (#x8FE9A6 #x99C9) (#x8FE9A7 #x99D3) (#x8FE9A8 #x99D4) (#x8FE9A9 #x99D9) (#x8FE9AA #x99DA) (#x8FE9AB #x99DC) (#x8FE9AC #x99DE) (#x8FE9AD #x99E7) (#x8FE9AE #x99EA) (#x8FE9AF #x99EB) (#x8FE9B0 #x99EC) (#x8FE9B1 #x99F0) (#x8FE9B2 #x99F4) (#x8FE9B3 #x99F5) (#x8FE9B4 #x99F9) (#x8FE9B5 #x99FD) (#x8FE9B6 #x99FE) (#x8FE9B7 #x9A02) (#x8FE9B8 #x9A03) (#x8FE9B9 #x9A04) (#x8FE9BA #x9A0B) (#x8FE9BB #x9A0C) (#x8FE9BC #x9A10) (#x8FE9BD #x9A11) (#x8FE9BE #x9A16) (#x8FE9BF #x9A1E) (#x8FE9C0 #x9A20) (#x8FE9C1 #x9A22) (#x8FE9C2 #x9A23) (#x8FE9C3 #x9A24) (#x8FE9C4 #x9A27) (#x8FE9C5 #x9A2D) (#x8FE9C6 #x9A2E) (#x8FE9C7 #x9A33) (#x8FE9C8 #x9A35) (#x8FE9C9 #x9A36) (#x8FE9CA #x9A38) (#x8FE9CB #x9A47) (#x8FE9CC #x9A41) (#x8FE9CD #x9A44) (#x8FE9CE #x9A4A) (#x8FE9CF #x9A4B) (#x8FE9D0 #x9A4C) (#x8FE9D1 #x9A4E) (#x8FE9D2 #x9A51) (#x8FE9D3 #x9A54) (#x8FE9D4 #x9A56) (#x8FE9D5 #x9A5D) (#x8FE9D6 #x9AAA) (#x8FE9D7 #x9AAC) (#x8FE9D8 #x9AAE) (#x8FE9D9 #x9AAF) (#x8FE9DA #x9AB2) (#x8FE9DB #x9AB4) (#x8FE9DC #x9AB5) (#x8FE9DD #x9AB6) (#x8FE9DE #x9AB9) (#x8FE9DF #x9ABB) (#x8FE9E0 #x9ABE) (#x8FE9E1 #x9ABF) (#x8FE9E2 #x9AC1) (#x8FE9E3 #x9AC3) (#x8FE9E4 #x9AC6) (#x8FE9E5 #x9AC8) (#x8FE9E6 #x9ACE) (#x8FE9E7 #x9AD0) (#x8FE9E8 #x9AD2) (#x8FE9E9 #x9AD5) (#x8FE9EA #x9AD6) (#x8FE9EB #x9AD7) (#x8FE9EC #x9ADB) (#x8FE9ED #x9ADC) (#x8FE9EE #x9AE0) (#x8FE9EF #x9AE4) (#x8FE9F0 #x9AE5) (#x8FE9F1 #x9AE7) (#x8FE9F2 #x9AE9) (#x8FE9F3 #x9AEC) (#x8FE9F4 #x9AF2) (#x8FE9F5 #x9AF3) (#x8FE9F6 #x9AF5) (#x8FE9F7 #x9AF9) (#x8FE9F8 #x9AFA) (#x8FE9F9 #x9AFD) (#x8FE9FA #x9AFF) (#x8FE9FB #x9B00) (#x8FE9FC #x9B01) (#x8FE9FD #x9B02) (#x8FE9FE #x9B03) (#x8FEAA1 #x9B04) (#x8FEAA2 #x9B05) (#x8FEAA3 #x9B08) (#x8FEAA4 #x9B09) (#x8FEAA5 #x9B0B) (#x8FEAA6 #x9B0C) (#x8FEAA7 #x9B0D) (#x8FEAA8 #x9B0E) (#x8FEAA9 #x9B10) (#x8FEAAA #x9B12) (#x8FEAAB #x9B16) (#x8FEAAC #x9B19) (#x8FEAAD #x9B1B) (#x8FEAAE #x9B1C) (#x8FEAAF #x9B20) (#x8FEAB0 #x9B26) (#x8FEAB1 #x9B2B) (#x8FEAB2 #x9B2D) (#x8FEAB3 #x9B33) (#x8FEAB4 #x9B34) (#x8FEAB5 #x9B35) (#x8FEAB6 #x9B37) (#x8FEAB7 #x9B39) (#x8FEAB8 #x9B3A) (#x8FEAB9 #x9B3D) (#x8FEABA #x9B48) (#x8FEABB #x9B4B) (#x8FEABC #x9B4C) (#x8FEABD #x9B55) (#x8FEABE #x9B56) (#x8FEABF #x9B57) (#x8FEAC0 #x9B5B) (#x8FEAC1 #x9B5E) (#x8FEAC2 #x9B61) (#x8FEAC3 #x9B63) (#x8FEAC4 #x9B65) (#x8FEAC5 #x9B66) (#x8FEAC6 #x9B68) (#x8FEAC7 #x9B6A) (#x8FEAC8 #x9B6B) (#x8FEAC9 #x9B6C) (#x8FEACA #x9B6D) (#x8FEACB #x9B6E) (#x8FEACC #x9B73) (#x8FEACD #x9B75) (#x8FEACE #x9B77) (#x8FEACF #x9B78) (#x8FEAD0 #x9B79) (#x8FEAD1 #x9B7F) (#x8FEAD2 #x9B80) (#x8FEAD3 #x9B84) (#x8FEAD4 #x9B85) (#x8FEAD5 #x9B86) (#x8FEAD6 #x9B87) (#x8FEAD7 #x9B89) (#x8FEAD8 #x9B8A) (#x8FEAD9 #x9B8B) (#x8FEADA #x9B8D) (#x8FEADB #x9B8F) (#x8FEADC #x9B90) (#x8FEADD #x9B94) (#x8FEADE #x9B9A) (#x8FEADF #x9B9D) (#x8FEAE0 #x9B9E) (#x8FEAE1 #x9BA6) (#x8FEAE2 #x9BA7) (#x8FEAE3 #x9BA9) (#x8FEAE4 #x9BAC) (#x8FEAE5 #x9BB0) (#x8FEAE6 #x9BB1) (#x8FEAE7 #x9BB2) (#x8FEAE8 #x9BB7) (#x8FEAE9 #x9BB8) (#x8FEAEA #x9BBB) (#x8FEAEB #x9BBC) (#x8FEAEC #x9BBE) (#x8FEAED #x9BBF) (#x8FEAEE #x9BC1) (#x8FEAEF #x9BC7) (#x8FEAF0 #x9BC8) (#x8FEAF1 #x9BCE) (#x8FEAF2 #x9BD0) (#x8FEAF3 #x9BD7) (#x8FEAF4 #x9BD8) (#x8FEAF5 #x9BDD) (#x8FEAF6 #x9BDF) (#x8FEAF7 #x9BE5) (#x8FEAF8 #x9BE7) (#x8FEAF9 #x9BEA) (#x8FEAFA #x9BEB) (#x8FEAFB #x9BEF) (#x8FEAFC #x9BF3) (#x8FEAFD #x9BF7) (#x8FEAFE #x9BF8) (#x8FEBA1 #x9BF9) (#x8FEBA2 #x9BFA) (#x8FEBA3 #x9BFD) (#x8FEBA4 #x9BFF) (#x8FEBA5 #x9C00) (#x8FEBA6 #x9C02) (#x8FEBA7 #x9C0B) (#x8FEBA8 #x9C0F) (#x8FEBA9 #x9C11) (#x8FEBAA #x9C16) (#x8FEBAB #x9C18) (#x8FEBAC #x9C19) (#x8FEBAD #x9C1A) (#x8FEBAE #x9C1C) (#x8FEBAF #x9C1E) (#x8FEBB0 #x9C22) (#x8FEBB1 #x9C23) (#x8FEBB2 #x9C26) (#x8FEBB3 #x9C27) (#x8FEBB4 #x9C28) (#x8FEBB5 #x9C29) (#x8FEBB6 #x9C2A) (#x8FEBB7 #x9C31) (#x8FEBB8 #x9C35) (#x8FEBB9 #x9C36) (#x8FEBBA #x9C37) (#x8FEBBB #x9C3D) (#x8FEBBC #x9C41) (#x8FEBBD #x9C43) (#x8FEBBE #x9C44) (#x8FEBBF #x9C45) (#x8FEBC0 #x9C49) (#x8FEBC1 #x9C4A) (#x8FEBC2 #x9C4E) (#x8FEBC3 #x9C4F) (#x8FEBC4 #x9C50) (#x8FEBC5 #x9C53) (#x8FEBC6 #x9C54) (#x8FEBC7 #x9C56) (#x8FEBC8 #x9C58) (#x8FEBC9 #x9C5B) (#x8FEBCA #x9C5D) (#x8FEBCB #x9C5E) (#x8FEBCC #x9C5F) (#x8FEBCD #x9C63) (#x8FEBCE #x9C69) (#x8FEBCF #x9C6A) (#x8FEBD0 #x9C5C) (#x8FEBD1 #x9C6B) (#x8FEBD2 #x9C68) (#x8FEBD3 #x9C6E) (#x8FEBD4 #x9C70) (#x8FEBD5 #x9C72) (#x8FEBD6 #x9C75) (#x8FEBD7 #x9C77) (#x8FEBD8 #x9C7B) (#x8FEBD9 #x9CE6) (#x8FEBDA #x9CF2) (#x8FEBDB #x9CF7) (#x8FEBDC #x9CF9) (#x8FEBDD #x9D0B) (#x8FEBDE #x9D02) (#x8FEBDF #x9D11) (#x8FEBE0 #x9D17) (#x8FEBE1 #x9D18) (#x8FEBE2 #x9D1C) (#x8FEBE3 #x9D1D) (#x8FEBE4 #x9D1E) (#x8FEBE5 #x9D2F) (#x8FEBE6 #x9D30) (#x8FEBE7 #x9D32) (#x8FEBE8 #x9D33) (#x8FEBE9 #x9D34) (#x8FEBEA #x9D3A) (#x8FEBEB #x9D3C) (#x8FEBEC #x9D45) (#x8FEBED #x9D3D) (#x8FEBEE #x9D42) (#x8FEBEF #x9D43) (#x8FEBF0 #x9D47) (#x8FEBF1 #x9D4A) (#x8FEBF2 #x9D53) (#x8FEBF3 #x9D54) (#x8FEBF4 #x9D5F) (#x8FEBF5 #x9D63) (#x8FEBF6 #x9D62) (#x8FEBF7 #x9D65) (#x8FEBF8 #x9D69) (#x8FEBF9 #x9D6A) (#x8FEBFA #x9D6B) (#x8FEBFB #x9D70) (#x8FEBFC #x9D76) (#x8FEBFD #x9D77) (#x8FEBFE #x9D7B) (#x8FECA1 #x9D7C) (#x8FECA2 #x9D7E) (#x8FECA3 #x9D83) (#x8FECA4 #x9D84) (#x8FECA5 #x9D86) (#x8FECA6 #x9D8A) (#x8FECA7 #x9D8D) (#x8FECA8 #x9D8E) (#x8FECA9 #x9D92) (#x8FECAA #x9D93) (#x8FECAB #x9D95) (#x8FECAC #x9D96) (#x8FECAD #x9D97) (#x8FECAE #x9D98) (#x8FECAF #x9DA1) (#x8FECB0 #x9DAA) (#x8FECB1 #x9DAC) (#x8FECB2 #x9DAE) (#x8FECB3 #x9DB1) (#x8FECB4 #x9DB5) (#x8FECB5 #x9DB9) (#x8FECB6 #x9DBC) (#x8FECB7 #x9DBF) (#x8FECB8 #x9DC3) (#x8FECB9 #x9DC7) (#x8FECBA #x9DC9) (#x8FECBB #x9DCA) (#x8FECBC #x9DD4) (#x8FECBD #x9DD5) (#x8FECBE #x9DD6) (#x8FECBF #x9DD7) (#x8FECC0 #x9DDA) (#x8FECC1 #x9DDE) (#x8FECC2 #x9DDF) (#x8FECC3 #x9DE0) (#x8FECC4 #x9DE5) (#x8FECC5 #x9DE7) (#x8FECC6 #x9DE9) (#x8FECC7 #x9DEB) (#x8FECC8 #x9DEE) (#x8FECC9 #x9DF0) (#x8FECCA #x9DF3) (#x8FECCB #x9DF4) (#x8FECCC #x9DFE) (#x8FECCD #x9E0A) (#x8FECCE #x9E02) (#x8FECCF #x9E07) (#x8FECD0 #x9E0E) (#x8FECD1 #x9E10) (#x8FECD2 #x9E11) (#x8FECD3 #x9E12) (#x8FECD4 #x9E15) (#x8FECD5 #x9E16) (#x8FECD6 #x9E19) (#x8FECD7 #x9E1C) (#x8FECD8 #x9E1D) (#x8FECD9 #x9E7A) (#x8FECDA #x9E7B) (#x8FECDB #x9E7C) (#x8FECDC #x9E80) (#x8FECDD #x9E82) (#x8FECDE #x9E83) (#x8FECDF #x9E84) (#x8FECE0 #x9E85) (#x8FECE1 #x9E87) (#x8FECE2 #x9E8E) (#x8FECE3 #x9E8F) (#x8FECE4 #x9E96) (#x8FECE5 #x9E98) (#x8FECE6 #x9E9B) (#x8FECE7 #x9E9E) (#x8FECE8 #x9EA4) (#x8FECE9 #x9EA8) (#x8FECEA #x9EAC) (#x8FECEB #x9EAE) (#x8FECEC #x9EAF) (#x8FECED #x9EB0) (#x8FECEE #x9EB3) (#x8FECEF #x9EB4) (#x8FECF0 #x9EB5) (#x8FECF1 #x9EC6) (#x8FECF2 #x9EC8) (#x8FECF3 #x9ECB) (#x8FECF4 #x9ED5) (#x8FECF5 #x9EDF) (#x8FECF6 #x9EE4) (#x8FECF7 #x9EE7) (#x8FECF8 #x9EEC) (#x8FECF9 #x9EED) (#x8FECFA #x9EEE) (#x8FECFB #x9EF0) (#x8FECFC #x9EF1) (#x8FECFD #x9EF2) (#x8FECFE #x9EF5) (#x8FEDA1 #x9EF8) (#x8FEDA2 #x9EFF) (#x8FEDA3 #x9F02) (#x8FEDA4 #x9F03) (#x8FEDA5 #x9F09) (#x8FEDA6 #x9F0F) (#x8FEDA7 #x9F10) (#x8FEDA8 #x9F11) (#x8FEDA9 #x9F12) (#x8FEDAA #x9F14) (#x8FEDAB #x9F16) (#x8FEDAC #x9F17) (#x8FEDAD #x9F19) (#x8FEDAE #x9F1A) (#x8FEDAF #x9F1B) (#x8FEDB0 #x9F1F) (#x8FEDB1 #x9F22) (#x8FEDB2 #x9F26) (#x8FEDB3 #x9F2A) (#x8FEDB4 #x9F2B) (#x8FEDB5 #x9F2F) (#x8FEDB6 #x9F31) (#x8FEDB7 #x9F32) (#x8FEDB8 #x9F34) (#x8FEDB9 #x9F37) (#x8FEDBA #x9F39) (#x8FEDBB #x9F3A) (#x8FEDBC #x9F3C) (#x8FEDBD #x9F3D) (#x8FEDBE #x9F3F) (#x8FEDBF #x9F41) (#x8FEDC0 #x9F43) (#x8FEDC1 #x9F44) (#x8FEDC2 #x9F45) (#x8FEDC3 #x9F46) (#x8FEDC4 #x9F47) (#x8FEDC5 #x9F53) (#x8FEDC6 #x9F55) (#x8FEDC7 #x9F56) (#x8FEDC8 #x9F57) (#x8FEDC9 #x9F58) (#x8FEDCA #x9F5A) (#x8FEDCB #x9F5D) (#x8FEDCC #x9F5E) (#x8FEDCD #x9F68) (#x8FEDCE #x9F69) (#x8FEDCF #x9F6D) (#x8FEDD0 #x9F6E) (#x8FEDD1 #x9F6F) (#x8FEDD2 #x9F70) (#x8FEDD3 #x9F71) (#x8FEDD4 #x9F73) (#x8FEDD5 #x9F75) (#x8FEDD6 #x9F7A) (#x8FEDD7 #x9F7D) (#x8FEDD8 #x9F8F) (#x8FEDD9 #x9F90) (#x8FEDDA #x9F91) (#x8FEDDB #x9F92) (#x8FEDDC #x9F94) (#x8FEDDD #x9F96) (#x8FEDDE #x9F97) (#x8FEDDF #x9F9E) (#x8FEDE0 #x9FA1) (#x8FEDE1 #x9FA2) (#x8FEDE2 #x9FA3) (#x8FEDE3 #x9FA5) (#x8FF5A1 #xE3AC) (#x8FF5A2 #xE3AD) (#x8FF5A3 #xE3AE) (#x8FF5A4 #xE3AF) (#x8FF5A5 #xE3B0) (#x8FF5A6 #xE3B1) (#x8FF5A7 #xE3B2) (#x8FF5A8 #xE3B3) (#x8FF5A9 #xE3B4) (#x8FF5AA #xE3B5) (#x8FF5AB #xE3B6) (#x8FF5AC #xE3B7) (#x8FF5AD #xE3B8) (#x8FF5AE #xE3B9) (#x8FF5AF #xE3BA) (#x8FF5B0 #xE3BB) (#x8FF5B1 #xE3BC) (#x8FF5B2 #xE3BD) (#x8FF5B3 #xE3BE) (#x8FF5B4 #xE3BF) (#x8FF5B5 #xE3C0) (#x8FF5B6 #xE3C1) (#x8FF5B7 #xE3C2) (#x8FF5B8 #xE3C3) (#x8FF5B9 #xE3C4) (#x8FF5BA #xE3C5) (#x8FF5BB #xE3C6) (#x8FF5BC #xE3C7) (#x8FF5BD #xE3C8) (#x8FF5BE #xE3C9) (#x8FF5BF #xE3CA) (#x8FF5C0 #xE3CB) (#x8FF5C1 #xE3CC) (#x8FF5C2 #xE3CD) (#x8FF5C3 #xE3CE) (#x8FF5C4 #xE3CF) (#x8FF5C5 #xE3D0) (#x8FF5C6 #xE3D1) (#x8FF5C7 #xE3D2) (#x8FF5C8 #xE3D3) (#x8FF5C9 #xE3D4) (#x8FF5CA #xE3D5) (#x8FF5CB #xE3D6) (#x8FF5CC #xE3D7) (#x8FF5CD #xE3D8) (#x8FF5CE #xE3D9) (#x8FF5CF #xE3DA) (#x8FF5D0 #xE3DB) (#x8FF5D1 #xE3DC) (#x8FF5D2 #xE3DD) (#x8FF5D3 #xE3DE) (#x8FF5D4 #xE3DF) (#x8FF5D5 #xE3E0) (#x8FF5D6 #xE3E1) (#x8FF5D7 #xE3E2) (#x8FF5D8 #xE3E3) (#x8FF5D9 #xE3E4) (#x8FF5DA #xE3E5) (#x8FF5DB #xE3E6) (#x8FF5DC #xE3E7) (#x8FF5DD #xE3E8) (#x8FF5DE #xE3E9) (#x8FF5DF #xE3EA) (#x8FF5E0 #xE3EB) (#x8FF5E1 #xE3EC) (#x8FF5E2 #xE3ED) (#x8FF5E3 #xE3EE) (#x8FF5E4 #xE3EF) (#x8FF5E5 #xE3F0) (#x8FF5E6 #xE3F1) (#x8FF5E7 #xE3F2) (#x8FF5E8 #xE3F3) (#x8FF5E9 #xE3F4) (#x8FF5EA #xE3F5) (#x8FF5EB #xE3F6) (#x8FF5EC #xE3F7) (#x8FF5ED #xE3F8) (#x8FF5EE #xE3F9) (#x8FF5EF #xE3FA) (#x8FF5F0 #xE3FB) (#x8FF5F1 #xE3FC) (#x8FF5F2 #xE3FD) (#x8FF5F3 #xE3FE) (#x8FF5F4 #xE3FF) (#x8FF5F5 #xE400) (#x8FF5F6 #xE401) (#x8FF5F7 #xE402) (#x8FF5F8 #xE403) (#x8FF5F9 #xE404) (#x8FF5FA #xE405) (#x8FF5FB #xE406) (#x8FF5FC #xE407) (#x8FF5FD #xE408) (#x8FF5FE #xE409) (#x8FF6A1 #xE40A) (#x8FF6A2 #xE40B) (#x8FF6A3 #xE40C) (#x8FF6A4 #xE40D) (#x8FF6A5 #xE40E) (#x8FF6A6 #xE40F) (#x8FF6A7 #xE410) (#x8FF6A8 #xE411) (#x8FF6A9 #xE412) (#x8FF6AA #xE413) (#x8FF6AB #xE414) (#x8FF6AC #xE415) (#x8FF6AD #xE416) (#x8FF6AE #xE417) (#x8FF6AF #xE418) (#x8FF6B0 #xE419) (#x8FF6B1 #xE41A) (#x8FF6B2 #xE41B) (#x8FF6B3 #xE41C) (#x8FF6B4 #xE41D) (#x8FF6B5 #xE41E) (#x8FF6B6 #xE41F) (#x8FF6B7 #xE420) (#x8FF6B8 #xE421) (#x8FF6B9 #xE422) (#x8FF6BA #xE423) (#x8FF6BB #xE424) (#x8FF6BC #xE425) (#x8FF6BD #xE426) (#x8FF6BE #xE427) (#x8FF6BF #xE428) (#x8FF6C0 #xE429) (#x8FF6C1 #xE42A) (#x8FF6C2 #xE42B) (#x8FF6C3 #xE42C) (#x8FF6C4 #xE42D) (#x8FF6C5 #xE42E) (#x8FF6C6 #xE42F) (#x8FF6C7 #xE430) (#x8FF6C8 #xE431) (#x8FF6C9 #xE432) (#x8FF6CA #xE433) (#x8FF6CB #xE434) (#x8FF6CC #xE435) (#x8FF6CD #xE436) (#x8FF6CE #xE437) (#x8FF6CF #xE438) (#x8FF6D0 #xE439) (#x8FF6D1 #xE43A) (#x8FF6D2 #xE43B) (#x8FF6D3 #xE43C) (#x8FF6D4 #xE43D) (#x8FF6D5 #xE43E) (#x8FF6D6 #xE43F) (#x8FF6D7 #xE440) (#x8FF6D8 #xE441) (#x8FF6D9 #xE442) (#x8FF6DA #xE443) (#x8FF6DB #xE444) (#x8FF6DC #xE445) (#x8FF6DD #xE446) (#x8FF6DE #xE447) (#x8FF6DF #xE448) (#x8FF6E0 #xE449) (#x8FF6E1 #xE44A) (#x8FF6E2 #xE44B) (#x8FF6E3 #xE44C) (#x8FF6E4 #xE44D) (#x8FF6E5 #xE44E) (#x8FF6E6 #xE44F) (#x8FF6E7 #xE450) (#x8FF6E8 #xE451) (#x8FF6E9 #xE452) (#x8FF6EA #xE453) (#x8FF6EB #xE454) (#x8FF6EC #xE455) (#x8FF6ED #xE456) (#x8FF6EE #xE457) (#x8FF6EF #xE458) (#x8FF6F0 #xE459) (#x8FF6F1 #xE45A) (#x8FF6F2 #xE45B) (#x8FF6F3 #xE45C) (#x8FF6F4 #xE45D) (#x8FF6F5 #xE45E) (#x8FF6F6 #xE45F) (#x8FF6F7 #xE460) (#x8FF6F8 #xE461) (#x8FF6F9 #xE462) (#x8FF6FA #xE463) (#x8FF6FB #xE464) (#x8FF6FC #xE465) (#x8FF6FD #xE466) (#x8FF6FE #xE467) (#x8FF7A1 #xE468) (#x8FF7A2 #xE469) (#x8FF7A3 #xE46A) (#x8FF7A4 #xE46B) (#x8FF7A5 #xE46C) (#x8FF7A6 #xE46D) (#x8FF7A7 #xE46E) (#x8FF7A8 #xE46F) (#x8FF7A9 #xE470) (#x8FF7AA #xE471) (#x8FF7AB #xE472) (#x8FF7AC #xE473) (#x8FF7AD #xE474) (#x8FF7AE #xE475) (#x8FF7AF #xE476) (#x8FF7B0 #xE477) (#x8FF7B1 #xE478) (#x8FF7B2 #xE479) (#x8FF7B3 #xE47A) (#x8FF7B4 #xE47B) (#x8FF7B5 #xE47C) (#x8FF7B6 #xE47D) (#x8FF7B7 #xE47E) (#x8FF7B8 #xE47F) (#x8FF7B9 #xE480) (#x8FF7BA #xE481) (#x8FF7BB #xE482) (#x8FF7BC #xE483) (#x8FF7BD #xE484) (#x8FF7BE #xE485) (#x8FF7BF #xE486) (#x8FF7C0 #xE487) (#x8FF7C1 #xE488) (#x8FF7C2 #xE489) (#x8FF7C3 #xE48A) (#x8FF7C4 #xE48B) (#x8FF7C5 #xE48C) (#x8FF7C6 #xE48D) (#x8FF7C7 #xE48E) (#x8FF7C8 #xE48F) (#x8FF7C9 #xE490) (#x8FF7CA #xE491) (#x8FF7CB #xE492) (#x8FF7CC #xE493) (#x8FF7CD #xE494) (#x8FF7CE #xE495) (#x8FF7CF #xE496) (#x8FF7D0 #xE497) (#x8FF7D1 #xE498) (#x8FF7D2 #xE499) (#x8FF7D3 #xE49A) (#x8FF7D4 #xE49B) (#x8FF7D5 #xE49C) (#x8FF7D6 #xE49D) (#x8FF7D7 #xE49E) (#x8FF7D8 #xE49F) (#x8FF7D9 #xE4A0) (#x8FF7DA #xE4A1) (#x8FF7DB #xE4A2) (#x8FF7DC #xE4A3) (#x8FF7DD #xE4A4) (#x8FF7DE #xE4A5) (#x8FF7DF #xE4A6) (#x8FF7E0 #xE4A7) (#x8FF7E1 #xE4A8) (#x8FF7E2 #xE4A9) (#x8FF7E3 #xE4AA) (#x8FF7E4 #xE4AB) (#x8FF7E5 #xE4AC) (#x8FF7E6 #xE4AD) (#x8FF7E7 #xE4AE) (#x8FF7E8 #xE4AF) (#x8FF7E9 #xE4B0) (#x8FF7EA #xE4B1) (#x8FF7EB #xE4B2) (#x8FF7EC #xE4B3) (#x8FF7ED #xE4B4) (#x8FF7EE #xE4B5) (#x8FF7EF #xE4B6) (#x8FF7F0 #xE4B7) (#x8FF7F1 #xE4B8) (#x8FF7F2 #xE4B9) (#x8FF7F3 #xE4BA) (#x8FF7F4 #xE4BB) (#x8FF7F5 #xE4BC) (#x8FF7F6 #xE4BD) (#x8FF7F7 #xE4BE) (#x8FF7F8 #xE4BF) (#x8FF7F9 #xE4C0) (#x8FF7FA #xE4C1) (#x8FF7FB #xE4C2) (#x8FF7FC #xE4C3) (#x8FF7FD #xE4C4) (#x8FF7FE #xE4C5) (#x8FF8A1 #xE4C6) (#x8FF8A2 #xE4C7) (#x8FF8A3 #xE4C8) (#x8FF8A4 #xE4C9) (#x8FF8A5 #xE4CA) (#x8FF8A6 #xE4CB) (#x8FF8A7 #xE4CC) (#x8FF8A8 #xE4CD) (#x8FF8A9 #xE4CE) (#x8FF8AA #xE4CF) (#x8FF8AB #xE4D0) (#x8FF8AC #xE4D1) (#x8FF8AD #xE4D2) (#x8FF8AE #xE4D3) (#x8FF8AF #xE4D4) (#x8FF8B0 #xE4D5) (#x8FF8B1 #xE4D6) (#x8FF8B2 #xE4D7) (#x8FF8B3 #xE4D8) (#x8FF8B4 #xE4D9) (#x8FF8B5 #xE4DA) (#x8FF8B6 #xE4DB) (#x8FF8B7 #xE4DC) (#x8FF8B8 #xE4DD) (#x8FF8B9 #xE4DE) (#x8FF8BA #xE4DF) (#x8FF8BB #xE4E0) (#x8FF8BC #xE4E1) (#x8FF8BD #xE4E2) (#x8FF8BE #xE4E3) (#x8FF8BF #xE4E4) (#x8FF8C0 #xE4E5) (#x8FF8C1 #xE4E6) (#x8FF8C2 #xE4E7) (#x8FF8C3 #xE4E8) (#x8FF8C4 #xE4E9) (#x8FF8C5 #xE4EA) (#x8FF8C6 #xE4EB) (#x8FF8C7 #xE4EC) (#x8FF8C8 #xE4ED) (#x8FF8C9 #xE4EE) (#x8FF8CA #xE4EF) (#x8FF8CB #xE4F0) (#x8FF8CC #xE4F1) (#x8FF8CD #xE4F2) (#x8FF8CE #xE4F3) (#x8FF8CF #xE4F4) (#x8FF8D0 #xE4F5) (#x8FF8D1 #xE4F6) (#x8FF8D2 #xE4F7) (#x8FF8D3 #xE4F8) (#x8FF8D4 #xE4F9) (#x8FF8D5 #xE4FA) (#x8FF8D6 #xE4FB) (#x8FF8D7 #xE4FC) (#x8FF8D8 #xE4FD) (#x8FF8D9 #xE4FE) (#x8FF8DA #xE4FF) (#x8FF8DB #xE500) (#x8FF8DC #xE501) (#x8FF8DD #xE502) (#x8FF8DE #xE503) (#x8FF8DF #xE504) (#x8FF8E0 #xE505) (#x8FF8E1 #xE506) (#x8FF8E2 #xE507) (#x8FF8E3 #xE508) (#x8FF8E4 #xE509) (#x8FF8E5 #xE50A) (#x8FF8E6 #xE50B) (#x8FF8E7 #xE50C) (#x8FF8E8 #xE50D) (#x8FF8E9 #xE50E) (#x8FF8EA #xE50F) (#x8FF8EB #xE510) (#x8FF8EC #xE511) (#x8FF8ED #xE512) (#x8FF8EE #xE513) (#x8FF8EF #xE514) (#x8FF8F0 #xE515) (#x8FF8F1 #xE516) (#x8FF8F2 #xE517) (#x8FF8F3 #xE518) (#x8FF8F4 #xE519) (#x8FF8F5 #xE51A) (#x8FF8F6 #xE51B) (#x8FF8F7 #xE51C) (#x8FF8F8 #xE51D) (#x8FF8F9 #xE51E) (#x8FF8FA #xE51F) (#x8FF8FB #xE520) (#x8FF8FC #xE521) (#x8FF8FD #xE522) (#x8FF8FE #xE523) (#x8FF9A1 #xE524) (#x8FF9A2 #xE525) (#x8FF9A3 #xE526) (#x8FF9A4 #xE527) (#x8FF9A5 #xE528) (#x8FF9A6 #xE529) (#x8FF9A7 #xE52A) (#x8FF9A8 #xE52B) (#x8FF9A9 #xE52C) (#x8FF9AA #xE52D) (#x8FF9AB #xE52E) (#x8FF9AC #xE52F) (#x8FF9AD #xE530) (#x8FF9AE #xE531) (#x8FF9AF #xE532) (#x8FF9B0 #xE533) (#x8FF9B1 #xE534) (#x8FF9B2 #xE535) (#x8FF9B3 #xE536) (#x8FF9B4 #xE537) (#x8FF9B5 #xE538) (#x8FF9B6 #xE539) (#x8FF9B7 #xE53A) (#x8FF9B8 #xE53B) (#x8FF9B9 #xE53C) (#x8FF9BA #xE53D) (#x8FF9BB #xE53E) (#x8FF9BC #xE53F) (#x8FF9BD #xE540) (#x8FF9BE #xE541) (#x8FF9BF #xE542) (#x8FF9C0 #xE543) (#x8FF9C1 #xE544) (#x8FF9C2 #xE545) (#x8FF9C3 #xE546) (#x8FF9C4 #xE547) (#x8FF9C5 #xE548) (#x8FF9C6 #xE549) (#x8FF9C7 #xE54A) (#x8FF9C8 #xE54B) (#x8FF9C9 #xE54C) (#x8FF9CA #xE54D) (#x8FF9CB #xE54E) (#x8FF9CC #xE54F) (#x8FF9CD #xE550) (#x8FF9CE #xE551) (#x8FF9CF #xE552) (#x8FF9D0 #xE553) (#x8FF9D1 #xE554) (#x8FF9D2 #xE555) (#x8FF9D3 #xE556) (#x8FF9D4 #xE557) (#x8FF9D5 #xE558) (#x8FF9D6 #xE559) (#x8FF9D7 #xE55A) (#x8FF9D8 #xE55B) (#x8FF9D9 #xE55C) (#x8FF9DA #xE55D) (#x8FF9DB #xE55E) (#x8FF9DC #xE55F) (#x8FF9DD #xE560) (#x8FF9DE #xE561) (#x8FF9DF #xE562) (#x8FF9E0 #xE563) (#x8FF9E1 #xE564) (#x8FF9E2 #xE565) (#x8FF9E3 #xE566) (#x8FF9E4 #xE567) (#x8FF9E5 #xE568) (#x8FF9E6 #xE569) (#x8FF9E7 #xE56A) (#x8FF9E8 #xE56B) (#x8FF9E9 #xE56C) (#x8FF9EA #xE56D) (#x8FF9EB #xE56E) (#x8FF9EC #xE56F) (#x8FF9ED #xE570) (#x8FF9EE #xE571) (#x8FF9EF #xE572) (#x8FF9F0 #xE573) (#x8FF9F1 #xE574) (#x8FF9F2 #xE575) (#x8FF9F3 #xE576) (#x8FF9F4 #xE577) (#x8FF9F5 #xE578) (#x8FF9F6 #xE579) (#x8FF9F7 #xE57A) (#x8FF9F8 #xE57B) (#x8FF9F9 #xE57C) (#x8FF9FA #xE57D) (#x8FF9FB #xE57E) (#x8FF9FC #xE57F) (#x8FF9FD #xE580) (#x8FF9FE #xE581) (#x8FFAA1 #xE582) (#x8FFAA2 #xE583) (#x8FFAA3 #xE584) (#x8FFAA4 #xE585) (#x8FFAA5 #xE586) (#x8FFAA6 #xE587) (#x8FFAA7 #xE588) (#x8FFAA8 #xE589) (#x8FFAA9 #xE58A) (#x8FFAAA #xE58B) (#x8FFAAB #xE58C) (#x8FFAAC #xE58D) (#x8FFAAD #xE58E) (#x8FFAAE #xE58F) (#x8FFAAF #xE590) (#x8FFAB0 #xE591) (#x8FFAB1 #xE592) (#x8FFAB2 #xE593) (#x8FFAB3 #xE594) (#x8FFAB4 #xE595) (#x8FFAB5 #xE596) (#x8FFAB6 #xE597) (#x8FFAB7 #xE598) (#x8FFAB8 #xE599) (#x8FFAB9 #xE59A) (#x8FFABA #xE59B) (#x8FFABB #xE59C) (#x8FFABC #xE59D) (#x8FFABD #xE59E) (#x8FFABE #xE59F) (#x8FFABF #xE5A0) (#x8FFAC0 #xE5A1) (#x8FFAC1 #xE5A2) (#x8FFAC2 #xE5A3) (#x8FFAC3 #xE5A4) (#x8FFAC4 #xE5A5) (#x8FFAC5 #xE5A6) (#x8FFAC6 #xE5A7) (#x8FFAC7 #xE5A8) (#x8FFAC8 #xE5A9) (#x8FFAC9 #xE5AA) (#x8FFACA #xE5AB) (#x8FFACB #xE5AC) (#x8FFACC #xE5AD) (#x8FFACD #xE5AE) (#x8FFACE #xE5AF) (#x8FFACF #xE5B0) (#x8FFAD0 #xE5B1) (#x8FFAD1 #xE5B2) (#x8FFAD2 #xE5B3) (#x8FFAD3 #xE5B4) (#x8FFAD4 #xE5B5) (#x8FFAD5 #xE5B6) (#x8FFAD6 #xE5B7) (#x8FFAD7 #xE5B8) (#x8FFAD8 #xE5B9) (#x8FFAD9 #xE5BA) (#x8FFADA #xE5BB) (#x8FFADB #xE5BC) (#x8FFADC #xE5BD) (#x8FFADD #xE5BE) (#x8FFADE #xE5BF) (#x8FFADF #xE5C0) (#x8FFAE0 #xE5C1) (#x8FFAE1 #xE5C2) (#x8FFAE2 #xE5C3) (#x8FFAE3 #xE5C4) (#x8FFAE4 #xE5C5) (#x8FFAE5 #xE5C6) (#x8FFAE6 #xE5C7) (#x8FFAE7 #xE5C8) (#x8FFAE8 #xE5C9) (#x8FFAE9 #xE5CA) (#x8FFAEA #xE5CB) (#x8FFAEB #xE5CC) (#x8FFAEC #xE5CD) (#x8FFAED #xE5CE) (#x8FFAEE #xE5CF) (#x8FFAEF #xE5D0) (#x8FFAF0 #xE5D1) (#x8FFAF1 #xE5D2) (#x8FFAF2 #xE5D3) (#x8FFAF3 #xE5D4) (#x8FFAF4 #xE5D5) (#x8FFAF5 #xE5D6) (#x8FFAF6 #xE5D7) (#x8FFAF7 #xE5D8) (#x8FFAF8 #xE5D9) (#x8FFAF9 #xE5DA) (#x8FFAFA #xE5DB) (#x8FFAFB #xE5DC) (#x8FFAFC #xE5DD) (#x8FFAFD #xE5DE) (#x8FFAFE #xE5DF) (#x8FFBA1 #xE5E0) (#x8FFBA2 #xE5E1) (#x8FFBA3 #xE5E2) (#x8FFBA4 #xE5E3) (#x8FFBA5 #xE5E4) (#x8FFBA6 #xE5E5) (#x8FFBA7 #xE5E6) (#x8FFBA8 #xE5E7) (#x8FFBA9 #xE5E8) (#x8FFBAA #xE5E9) (#x8FFBAB #xE5EA) (#x8FFBAC #xE5EB) (#x8FFBAD #xE5EC) (#x8FFBAE #xE5ED) (#x8FFBAF #xE5EE) (#x8FFBB0 #xE5EF) (#x8FFBB1 #xE5F0) (#x8FFBB2 #xE5F1) (#x8FFBB3 #xE5F2) (#x8FFBB4 #xE5F3) (#x8FFBB5 #xE5F4) (#x8FFBB6 #xE5F5) (#x8FFBB7 #xE5F6) (#x8FFBB8 #xE5F7) (#x8FFBB9 #xE5F8) (#x8FFBBA #xE5F9) (#x8FFBBB #xE5FA) (#x8FFBBC #xE5FB) (#x8FFBBD #xE5FC) (#x8FFBBE #xE5FD) (#x8FFBBF #xE5FE) (#x8FFBC0 #xE5FF) (#x8FFBC1 #xE600) (#x8FFBC2 #xE601) (#x8FFBC3 #xE602) (#x8FFBC4 #xE603) (#x8FFBC5 #xE604) (#x8FFBC6 #xE605) (#x8FFBC7 #xE606) (#x8FFBC8 #xE607) (#x8FFBC9 #xE608) (#x8FFBCA #xE609) (#x8FFBCB #xE60A) (#x8FFBCC #xE60B) (#x8FFBCD #xE60C) (#x8FFBCE #xE60D) (#x8FFBCF #xE60E) (#x8FFBD0 #xE60F) (#x8FFBD1 #xE610) (#x8FFBD2 #xE611) (#x8FFBD3 #xE612) (#x8FFBD4 #xE613) (#x8FFBD5 #xE614) (#x8FFBD6 #xE615) (#x8FFBD7 #xE616) (#x8FFBD8 #xE617) (#x8FFBD9 #xE618) (#x8FFBDA #xE619) (#x8FFBDB #xE61A) (#x8FFBDC #xE61B) (#x8FFBDD #xE61C) (#x8FFBDE #xE61D) (#x8FFBDF #xE61E) (#x8FFBE0 #xE61F) (#x8FFBE1 #xE620) (#x8FFBE2 #xE621) (#x8FFBE3 #xE622) (#x8FFBE4 #xE623) (#x8FFBE5 #xE624) (#x8FFBE6 #xE625) (#x8FFBE7 #xE626) (#x8FFBE8 #xE627) (#x8FFBE9 #xE628) (#x8FFBEA #xE629) (#x8FFBEB #xE62A) (#x8FFBEC #xE62B) (#x8FFBED #xE62C) (#x8FFBEE #xE62D) (#x8FFBEF #xE62E) (#x8FFBF0 #xE62F) (#x8FFBF1 #xE630) (#x8FFBF2 #xE631) (#x8FFBF3 #xE632) (#x8FFBF4 #xE633) (#x8FFBF5 #xE634) (#x8FFBF6 #xE635) (#x8FFBF7 #xE636) (#x8FFBF8 #xE637) (#x8FFBF9 #xE638) (#x8FFBFA #xE639) (#x8FFBFB #xE63A) (#x8FFBFC #xE63B) (#x8FFBFD #xE63C) (#x8FFBFE #xE63D) (#x8FFCA1 #xE63E) (#x8FFCA2 #xE63F) (#x8FFCA3 #xE640) (#x8FFCA4 #xE641) (#x8FFCA5 #xE642) (#x8FFCA6 #xE643) (#x8FFCA7 #xE644) (#x8FFCA8 #xE645) (#x8FFCA9 #xE646) (#x8FFCAA #xE647) (#x8FFCAB #xE648) (#x8FFCAC #xE649) (#x8FFCAD #xE64A) (#x8FFCAE #xE64B) (#x8FFCAF #xE64C) (#x8FFCB0 #xE64D) (#x8FFCB1 #xE64E) (#x8FFCB2 #xE64F) (#x8FFCB3 #xE650) (#x8FFCB4 #xE651) (#x8FFCB5 #xE652) (#x8FFCB6 #xE653) (#x8FFCB7 #xE654) (#x8FFCB8 #xE655) (#x8FFCB9 #xE656) (#x8FFCBA #xE657) (#x8FFCBB #xE658) (#x8FFCBC #xE659) (#x8FFCBD #xE65A) (#x8FFCBE #xE65B) (#x8FFCBF #xE65C) (#x8FFCC0 #xE65D) (#x8FFCC1 #xE65E) (#x8FFCC2 #xE65F) (#x8FFCC3 #xE660) (#x8FFCC4 #xE661) (#x8FFCC5 #xE662) (#x8FFCC6 #xE663) (#x8FFCC7 #xE664) (#x8FFCC8 #xE665) (#x8FFCC9 #xE666) (#x8FFCCA #xE667) (#x8FFCCB #xE668) (#x8FFCCC #xE669) (#x8FFCCD #xE66A) (#x8FFCCE #xE66B) (#x8FFCCF #xE66C) (#x8FFCD0 #xE66D) (#x8FFCD1 #xE66E) (#x8FFCD2 #xE66F) (#x8FFCD3 #xE670) (#x8FFCD4 #xE671) (#x8FFCD5 #xE672) (#x8FFCD6 #xE673) (#x8FFCD7 #xE674) (#x8FFCD8 #xE675) (#x8FFCD9 #xE676) (#x8FFCDA #xE677) (#x8FFCDB #xE678) (#x8FFCDC #xE679) (#x8FFCDD #xE67A) (#x8FFCDE #xE67B) (#x8FFCDF #xE67C) (#x8FFCE0 #xE67D) (#x8FFCE1 #xE67E) (#x8FFCE2 #xE67F) (#x8FFCE3 #xE680) (#x8FFCE4 #xE681) (#x8FFCE5 #xE682) (#x8FFCE6 #xE683) (#x8FFCE7 #xE684) (#x8FFCE8 #xE685) (#x8FFCE9 #xE686) (#x8FFCEA #xE687) (#x8FFCEB #xE688) (#x8FFCEC #xE689) (#x8FFCED #xE68A) (#x8FFCEE #xE68B) (#x8FFCEF #xE68C) (#x8FFCF0 #xE68D) (#x8FFCF1 #xE68E) (#x8FFCF2 #xE68F) (#x8FFCF3 #xE690) (#x8FFCF4 #xE691) (#x8FFCF5 #xE692) (#x8FFCF6 #xE693) (#x8FFCF7 #xE694) (#x8FFCF8 #xE695) (#x8FFCF9 #xE696) (#x8FFCFA #xE697) (#x8FFCFB #xE698) (#x8FFCFC #xE699) (#x8FFCFD #xE69A) (#x8FFCFE #xE69B) (#x8FFDA1 #xE69C) (#x8FFDA2 #xE69D) (#x8FFDA3 #xE69E) (#x8FFDA4 #xE69F) (#x8FFDA5 #xE6A0) (#x8FFDA6 #xE6A1) (#x8FFDA7 #xE6A2) (#x8FFDA8 #xE6A3) (#x8FFDA9 #xE6A4) (#x8FFDAA #xE6A5) (#x8FFDAB #xE6A6) (#x8FFDAC #xE6A7) (#x8FFDAD #xE6A8) (#x8FFDAE #xE6A9) (#x8FFDAF #xE6AA) (#x8FFDB0 #xE6AB) (#x8FFDB1 #xE6AC) (#x8FFDB2 #xE6AD) (#x8FFDB3 #xE6AE) (#x8FFDB4 #xE6AF) (#x8FFDB5 #xE6B0) (#x8FFDB6 #xE6B1) (#x8FFDB7 #xE6B2) (#x8FFDB8 #xE6B3) (#x8FFDB9 #xE6B4) (#x8FFDBA #xE6B5) (#x8FFDBB #xE6B6) (#x8FFDBC #xE6B7) (#x8FFDBD #xE6B8) (#x8FFDBE #xE6B9) (#x8FFDBF #xE6BA) (#x8FFDC0 #xE6BB) (#x8FFDC1 #xE6BC) (#x8FFDC2 #xE6BD) (#x8FFDC3 #xE6BE) (#x8FFDC4 #xE6BF) (#x8FFDC5 #xE6C0) (#x8FFDC6 #xE6C1) (#x8FFDC7 #xE6C2) (#x8FFDC8 #xE6C3) (#x8FFDC9 #xE6C4) (#x8FFDCA #xE6C5) (#x8FFDCB #xE6C6) (#x8FFDCC #xE6C7) (#x8FFDCD #xE6C8) (#x8FFDCE #xE6C9) (#x8FFDCF #xE6CA) (#x8FFDD0 #xE6CB) (#x8FFDD1 #xE6CC) (#x8FFDD2 #xE6CD) (#x8FFDD3 #xE6CE) (#x8FFDD4 #xE6CF) (#x8FFDD5 #xE6D0) (#x8FFDD6 #xE6D1) (#x8FFDD7 #xE6D2) (#x8FFDD8 #xE6D3) (#x8FFDD9 #xE6D4) (#x8FFDDA #xE6D5) (#x8FFDDB #xE6D6) (#x8FFDDC #xE6D7) (#x8FFDDD #xE6D8) (#x8FFDDE #xE6D9) (#x8FFDDF #xE6DA) (#x8FFDE0 #xE6DB) (#x8FFDE1 #xE6DC) (#x8FFDE2 #xE6DD) (#x8FFDE3 #xE6DE) (#x8FFDE4 #xE6DF) (#x8FFDE5 #xE6E0) (#x8FFDE6 #xE6E1) (#x8FFDE7 #xE6E2) (#x8FFDE8 #xE6E3) (#x8FFDE9 #xE6E4) (#x8FFDEA #xE6E5) (#x8FFDEB #xE6E6) (#x8FFDEC #xE6E7) (#x8FFDED #xE6E8) (#x8FFDEE #xE6E9) (#x8FFDEF #xE6EA) (#x8FFDF0 #xE6EB) (#x8FFDF1 #xE6EC) (#x8FFDF2 #xE6ED) (#x8FFDF3 #xE6EE) (#x8FFDF4 #xE6EF) (#x8FFDF5 #xE6F0) (#x8FFDF6 #xE6F1) (#x8FFDF7 #xE6F2) (#x8FFDF8 #xE6F3) (#x8FFDF9 #xE6F4) (#x8FFDFA #xE6F5) (#x8FFDFB #xE6F6) (#x8FFDFC #xE6F7) (#x8FFDFD #xE6F8) (#x8FFDFE #xE6F9) (#x8FFEA1 #xE6FA) (#x8FFEA2 #xE6FB) (#x8FFEA3 #xE6FC) (#x8FFEA4 #xE6FD) (#x8FFEA5 #xE6FE) (#x8FFEA6 #xE6FF) (#x8FFEA7 #xE700) (#x8FFEA8 #xE701) (#x8FFEA9 #xE702) (#x8FFEAA #xE703) (#x8FFEAB #xE704) (#x8FFEAC #xE705) (#x8FFEAD #xE706) (#x8FFEAE #xE707) (#x8FFEAF #xE708) (#x8FFEB0 #xE709) (#x8FFEB1 #xE70A) (#x8FFEB2 #xE70B) (#x8FFEB3 #xE70C) (#x8FFEB4 #xE70D) (#x8FFEB5 #xE70E) (#x8FFEB6 #xE70F) (#x8FFEB7 #xE710) (#x8FFEB8 #xE711) (#x8FFEB9 #xE712) (#x8FFEBA #xE713) (#x8FFEBB #xE714) (#x8FFEBC #xE715) (#x8FFEBD #xE716) (#x8FFEBE #xE717) (#x8FFEBF #xE718) (#x8FFEC0 #xE719) (#x8FFEC1 #xE71A) (#x8FFEC2 #xE71B) (#x8FFEC3 #xE71C) (#x8FFEC4 #xE71D) (#x8FFEC5 #xE71E) (#x8FFEC6 #xE71F) (#x8FFEC7 #xE720) (#x8FFEC8 #xE721) (#x8FFEC9 #xE722) (#x8FFECA #xE723) (#x8FFECB #xE724) (#x8FFECC #xE725) (#x8FFECD #xE726) (#x8FFECE #xE727) (#x8FFECF #xE728) (#x8FFED0 #xE729) (#x8FFED1 #xE72A) (#x8FFED2 #xE72B) (#x8FFED3 #xE72C) (#x8FFED4 #xE72D) (#x8FFED5 #xE72E) (#x8FFED6 #xE72F) (#x8FFED7 #xE730) (#x8FFED8 #xE731) (#x8FFED9 #xE732) (#x8FFEDA #xE733) (#x8FFEDB #xE734) (#x8FFEDC #xE735) (#x8FFEDD #xE736) (#x8FFEDE #xE737) (#x8FFEDF #xE738) (#x8FFEE0 #xE739) (#x8FFEE1 #xE73A) (#x8FFEE2 #xE73B) (#x8FFEE3 #xE73C) (#x8FFEE4 #xE73D) (#x8FFEE5 #xE73E) (#x8FFEE6 #xE73F) (#x8FFEE7 #xE740) (#x8FFEE8 #xE741) (#x8FFEE9 #xE742) (#x8FFEEA #xE743) (#x8FFEEB #xE744) (#x8FFEEC #xE745) (#x8FFEED #xE746) (#x8FFEEE #xE747) (#x8FFEEF #xE748) (#x8FFEF0 #xE749) (#x8FFEF1 #xE74A) (#x8FFEF2 #xE74B) (#x8FFEF3 #xE74C) (#x8FFEF4 #xE74D) (#x8FFEF5 #xE74E) (#x8FFEF6 #xE74F) (#x8FFEF7 #xE750) (#x8FFEF8 #xE751) (#x8FFEF9 #xE752) (#x8FFEFA #xE753) (#x8FFEFB #xE754) (#x8FFEFC #xE755) (#x8FFEFD #xE756) (#x8FFEFE #xE757) (#xA1A1 #x3000) (#xA1A2 #x3001) (#xA1A3 #x3002) (#xA1A4 #xFF0C) (#xA1A5 #xFF0E) (#xA1A6 #x30FB) (#xA1A7 #xFF1A) (#xA1A8 #xFF1B) (#xA1A9 #xFF1F) (#xA1AA #xFF01) (#xA1AB #x309B) (#xA1AC #x309C) (#xA1AD #xB4) (#xA1AE #xFF40) (#xA1AF #xA8) (#xA1B0 #xFF3E) (#xA1B1 #xFFE3) (#xA1B2 #xFF3F) (#xA1B3 #x30FD) (#xA1B4 #x30FE) (#xA1B5 #x309D) (#xA1B6 #x309E) (#xA1B7 #x3003) (#xA1B8 #x4EDD) (#xA1B9 #x3005) (#xA1BA #x3006) (#xA1BB #x3007) (#xA1BC #x30FC) (#xA1BD #x2015) (#xA1BE #x2010) (#xA1BF #xFF0F) (#xA1C0 #xFF3C) (#xA1C1 #x301C) (#xA1C2 #x2016) (#xA1C3 #xFF5C) (#xA1C4 #x2026) (#xA1C5 #x2025) (#xA1C6 #x2018) (#xA1C7 #x2019) (#xA1C8 #x201C) (#xA1C9 #x201D) (#xA1CA #xFF08) (#xA1CB #xFF09) (#xA1CC #x3014) (#xA1CD #x3015) (#xA1CE #xFF3B) (#xA1CF #xFF3D) (#xA1D0 #xFF5B) (#xA1D1 #xFF5D) (#xA1D2 #x3008) (#xA1D3 #x3009) (#xA1D4 #x300A) (#xA1D5 #x300B) (#xA1D6 #x300C) (#xA1D7 #x300D) (#xA1D8 #x300E) (#xA1D9 #x300F) (#xA1DA #x3010) (#xA1DB #x3011) (#xA1DC #xFF0B) (#xA1DD #x2212) (#xA1DE #xB1) (#xA1DF #xD7) (#xA1E0 #xF7) (#xA1E1 #xFF1D) (#xA1E2 #x2260) (#xA1E3 #xFF1C) (#xA1E4 #xFF1E) (#xA1E5 #x2266) (#xA1E6 #x2267) (#xA1E7 #x221E) (#xA1E8 #x2234) (#xA1E9 #x2642) (#xA1EA #x2640) (#xA1EB #xB0) (#xA1EC #x2032) (#xA1ED #x2033) (#xA1EE #x2103) (#xA1EF #xFFE5) (#xA1F0 #xFF04) (#xA1F1 #xA2) (#xA1F2 #xA3) (#xA1F3 #xFF05) (#xA1F4 #xFF03) (#xA1F5 #xFF06) (#xA1F6 #xFF0A) (#xA1F7 #xFF20) (#xA1F8 #xA7) (#xA1F9 #x2606) (#xA1FA #x2605) (#xA1FB #x25CB) (#xA1FC #x25CF) (#xA1FD #x25CE) (#xA1FE #x25C7) (#xA2A1 #x25C6) (#xA2A2 #x25A1) (#xA2A3 #x25A0) (#xA2A4 #x25B3) (#xA2A5 #x25B2) (#xA2A6 #x25BD) (#xA2A7 #x25BC) (#xA2A8 #x203B) (#xA2A9 #x3012) (#xA2AA #x2192) (#xA2AB #x2190) (#xA2AC #x2191) (#xA2AD #x2193) (#xA2AE #x3013) (#xA2BA #x2208) (#xA2BB #x220B) (#xA2BC #x2286) (#xA2BD #x2287) (#xA2BE #x2282) (#xA2BF #x2283) (#xA2C0 #x222A) (#xA2C1 #x2229) (#xA2CA #x2227) (#xA2CB #x2228) (#xA2CC #xAC) (#xA2CD #x21D2) (#xA2CE #x21D4) (#xA2CF #x2200) (#xA2D0 #x2203) (#xA2DC #x2220) (#xA2DD #x22A5) (#xA2DE #x2312) (#xA2DF #x2202) (#xA2E0 #x2207) (#xA2E1 #x2261) (#xA2E2 #x2252) (#xA2E3 #x226A) (#xA2E4 #x226B) (#xA2E5 #x221A) (#xA2E6 #x223D) (#xA2E7 #x221D) (#xA2E8 #x2235) (#xA2E9 #x222B) (#xA2EA #x222C) (#xA2F2 #x212B) (#xA2F3 #x2030) (#xA2F4 #x266F) (#xA2F5 #x266D) (#xA2F6 #x266A) (#xA2F7 #x2020) (#xA2F8 #x2021) (#xA2F9 #xB6) (#xA2FE #x25EF) (#xA3B0 #xFF10) (#xA3B1 #xFF11) (#xA3B2 #xFF12) (#xA3B3 #xFF13) (#xA3B4 #xFF14) (#xA3B5 #xFF15) (#xA3B6 #xFF16) (#xA3B7 #xFF17) (#xA3B8 #xFF18) (#xA3B9 #xFF19) (#xA3C1 #xFF21) (#xA3C2 #xFF22) (#xA3C3 #xFF23) (#xA3C4 #xFF24) (#xA3C5 #xFF25) (#xA3C6 #xFF26) (#xA3C7 #xFF27) (#xA3C8 #xFF28) (#xA3C9 #xFF29) (#xA3CA #xFF2A) (#xA3CB #xFF2B) (#xA3CC #xFF2C) (#xA3CD #xFF2D) (#xA3CE #xFF2E) (#xA3CF #xFF2F) (#xA3D0 #xFF30) (#xA3D1 #xFF31) (#xA3D2 #xFF32) (#xA3D3 #xFF33) (#xA3D4 #xFF34) (#xA3D5 #xFF35) (#xA3D6 #xFF36) (#xA3D7 #xFF37) (#xA3D8 #xFF38) (#xA3D9 #xFF39) (#xA3DA #xFF3A) (#xA3E1 #xFF41) (#xA3E2 #xFF42) (#xA3E3 #xFF43) (#xA3E4 #xFF44) (#xA3E5 #xFF45) (#xA3E6 #xFF46) (#xA3E7 #xFF47) (#xA3E8 #xFF48) (#xA3E9 #xFF49) (#xA3EA #xFF4A) (#xA3EB #xFF4B) (#xA3EC #xFF4C) (#xA3ED #xFF4D) (#xA3EE #xFF4E) (#xA3EF #xFF4F) (#xA3F0 #xFF50) (#xA3F1 #xFF51) (#xA3F2 #xFF52) (#xA3F3 #xFF53) (#xA3F4 #xFF54) (#xA3F5 #xFF55) (#xA3F6 #xFF56) (#xA3F7 #xFF57) (#xA3F8 #xFF58) (#xA3F9 #xFF59) (#xA3FA #xFF5A) (#xA4A1 #x3041) (#xA4A2 #x3042) (#xA4A3 #x3043) (#xA4A4 #x3044) (#xA4A5 #x3045) (#xA4A6 #x3046) (#xA4A7 #x3047) (#xA4A8 #x3048) (#xA4A9 #x3049) (#xA4AA #x304A) (#xA4AB #x304B) (#xA4AC #x304C) (#xA4AD #x304D) (#xA4AE #x304E) (#xA4AF #x304F) (#xA4B0 #x3050) (#xA4B1 #x3051) (#xA4B2 #x3052) (#xA4B3 #x3053) (#xA4B4 #x3054) (#xA4B5 #x3055) (#xA4B6 #x3056) (#xA4B7 #x3057) (#xA4B8 #x3058) (#xA4B9 #x3059) (#xA4BA #x305A) (#xA4BB #x305B) (#xA4BC #x305C) (#xA4BD #x305D) (#xA4BE #x305E) (#xA4BF #x305F) (#xA4C0 #x3060) (#xA4C1 #x3061) (#xA4C2 #x3062) (#xA4C3 #x3063) (#xA4C4 #x3064) (#xA4C5 #x3065) (#xA4C6 #x3066) (#xA4C7 #x3067) (#xA4C8 #x3068) (#xA4C9 #x3069) (#xA4CA #x306A) (#xA4CB #x306B) (#xA4CC #x306C) (#xA4CD #x306D) (#xA4CE #x306E) (#xA4CF #x306F) (#xA4D0 #x3070) (#xA4D1 #x3071) (#xA4D2 #x3072) (#xA4D3 #x3073) (#xA4D4 #x3074) (#xA4D5 #x3075) (#xA4D6 #x3076) (#xA4D7 #x3077) (#xA4D8 #x3078) (#xA4D9 #x3079) (#xA4DA #x307A) (#xA4DB #x307B) (#xA4DC #x307C) (#xA4DD #x307D) (#xA4DE #x307E) (#xA4DF #x307F) (#xA4E0 #x3080) (#xA4E1 #x3081) (#xA4E2 #x3082) (#xA4E3 #x3083) (#xA4E4 #x3084) (#xA4E5 #x3085) (#xA4E6 #x3086) (#xA4E7 #x3087) (#xA4E8 #x3088) (#xA4E9 #x3089) (#xA4EA #x308A) (#xA4EB #x308B) (#xA4EC #x308C) (#xA4ED #x308D) (#xA4EE #x308E) (#xA4EF #x308F) (#xA4F0 #x3090) (#xA4F1 #x3091) (#xA4F2 #x3092) (#xA4F3 #x3093) (#xA5A1 #x30A1) (#xA5A2 #x30A2) (#xA5A3 #x30A3) (#xA5A4 #x30A4) (#xA5A5 #x30A5) (#xA5A6 #x30A6) (#xA5A7 #x30A7) (#xA5A8 #x30A8) (#xA5A9 #x30A9) (#xA5AA #x30AA) (#xA5AB #x30AB) (#xA5AC #x30AC) (#xA5AD #x30AD) (#xA5AE #x30AE) (#xA5AF #x30AF) (#xA5B0 #x30B0) (#xA5B1 #x30B1) (#xA5B2 #x30B2) (#xA5B3 #x30B3) (#xA5B4 #x30B4) (#xA5B5 #x30B5) (#xA5B6 #x30B6) (#xA5B7 #x30B7) (#xA5B8 #x30B8) (#xA5B9 #x30B9) (#xA5BA #x30BA) (#xA5BB #x30BB) (#xA5BC #x30BC) (#xA5BD #x30BD) (#xA5BE #x30BE) (#xA5BF #x30BF) (#xA5C0 #x30C0) (#xA5C1 #x30C1) (#xA5C2 #x30C2) (#xA5C3 #x30C3) (#xA5C4 #x30C4) (#xA5C5 #x30C5) (#xA5C6 #x30C6) (#xA5C7 #x30C7) (#xA5C8 #x30C8) (#xA5C9 #x30C9) (#xA5CA #x30CA) (#xA5CB #x30CB) (#xA5CC #x30CC) (#xA5CD #x30CD) (#xA5CE #x30CE) (#xA5CF #x30CF) (#xA5D0 #x30D0) (#xA5D1 #x30D1) (#xA5D2 #x30D2) (#xA5D3 #x30D3) (#xA5D4 #x30D4) (#xA5D5 #x30D5) (#xA5D6 #x30D6) (#xA5D7 #x30D7) (#xA5D8 #x30D8) (#xA5D9 #x30D9) (#xA5DA #x30DA) (#xA5DB #x30DB) (#xA5DC #x30DC) (#xA5DD #x30DD) (#xA5DE #x30DE) (#xA5DF #x30DF) (#xA5E0 #x30E0) (#xA5E1 #x30E1) (#xA5E2 #x30E2) (#xA5E3 #x30E3) (#xA5E4 #x30E4) (#xA5E5 #x30E5) (#xA5E6 #x30E6) (#xA5E7 #x30E7) (#xA5E8 #x30E8) (#xA5E9 #x30E9) (#xA5EA #x30EA) (#xA5EB #x30EB) (#xA5EC #x30EC) (#xA5ED #x30ED) (#xA5EE #x30EE) (#xA5EF #x30EF) (#xA5F0 #x30F0) (#xA5F1 #x30F1) (#xA5F2 #x30F2) (#xA5F3 #x30F3) (#xA5F4 #x30F4) (#xA5F5 #x30F5) (#xA5F6 #x30F6) (#xA6A1 #x391) (#xA6A2 #x392) (#xA6A3 #x393) (#xA6A4 #x394) (#xA6A5 #x395) (#xA6A6 #x396) (#xA6A7 #x397) (#xA6A8 #x398) (#xA6A9 #x399) (#xA6AA #x39A) (#xA6AB #x39B) (#xA6AC #x39C) (#xA6AD #x39D) (#xA6AE #x39E) (#xA6AF #x39F) (#xA6B0 #x3A0) (#xA6B1 #x3A1) (#xA6B2 #x3A3) (#xA6B3 #x3A4) (#xA6B4 #x3A5) (#xA6B5 #x3A6) (#xA6B6 #x3A7) (#xA6B7 #x3A8) (#xA6B8 #x3A9) (#xA6C1 #x3B1) (#xA6C2 #x3B2) (#xA6C3 #x3B3) (#xA6C4 #x3B4) (#xA6C5 #x3B5) (#xA6C6 #x3B6) (#xA6C7 #x3B7) (#xA6C8 #x3B8) (#xA6C9 #x3B9) (#xA6CA #x3BA) (#xA6CB #x3BB) (#xA6CC #x3BC) (#xA6CD #x3BD) (#xA6CE #x3BE) (#xA6CF #x3BF) (#xA6D0 #x3C0) (#xA6D1 #x3C1) (#xA6D2 #x3C3) (#xA6D3 #x3C4) (#xA6D4 #x3C5) (#xA6D5 #x3C6) (#xA6D6 #x3C7) (#xA6D7 #x3C8) (#xA6D8 #x3C9) (#xA7A1 #x410) (#xA7A2 #x411) (#xA7A3 #x412) (#xA7A4 #x413) (#xA7A5 #x414) (#xA7A6 #x415) (#xA7A7 #x401) (#xA7A8 #x416) (#xA7A9 #x417) (#xA7AA #x418) (#xA7AB #x419) (#xA7AC #x41A) (#xA7AD #x41B) (#xA7AE #x41C) (#xA7AF #x41D) (#xA7B0 #x41E) (#xA7B1 #x41F) (#xA7B2 #x420) (#xA7B3 #x421) (#xA7B4 #x422) (#xA7B5 #x423) (#xA7B6 #x424) (#xA7B7 #x425) (#xA7B8 #x426) (#xA7B9 #x427) (#xA7BA #x428) (#xA7BB #x429) (#xA7BC #x42A) (#xA7BD #x42B) (#xA7BE #x42C) (#xA7BF #x42D) (#xA7C0 #x42E) (#xA7C1 #x42F) (#xA7D1 #x430) (#xA7D2 #x431) (#xA7D3 #x432) (#xA7D4 #x433) (#xA7D5 #x434) (#xA7D6 #x435) (#xA7D7 #x451) (#xA7D8 #x436) (#xA7D9 #x437) (#xA7DA #x438) (#xA7DB #x439) (#xA7DC #x43A) (#xA7DD #x43B) (#xA7DE #x43C) (#xA7DF #x43D) (#xA7E0 #x43E) (#xA7E1 #x43F) (#xA7E2 #x440) (#xA7E3 #x441) (#xA7E4 #x442) (#xA7E5 #x443) (#xA7E6 #x444) (#xA7E7 #x445) (#xA7E8 #x446) (#xA7E9 #x447) (#xA7EA #x448) (#xA7EB #x449) (#xA7EC #x44A) (#xA7ED #x44B) (#xA7EE #x44C) (#xA7EF #x44D) (#xA7F0 #x44E) (#xA7F1 #x44F) (#xA8A1 #x2500) (#xA8A2 #x2502) (#xA8A3 #x250C) (#xA8A4 #x2510) (#xA8A5 #x2518) (#xA8A6 #x2514) (#xA8A7 #x251C) (#xA8A8 #x252C) (#xA8A9 #x2524) (#xA8AA #x2534) (#xA8AB #x253C) (#xA8AC #x2501) (#xA8AD #x2503) (#xA8AE #x250F) (#xA8AF #x2513) (#xA8B0 #x251B) (#xA8B1 #x2517) (#xA8B2 #x2523) (#xA8B3 #x2533) (#xA8B4 #x252B) (#xA8B5 #x253B) (#xA8B6 #x254B) (#xA8B7 #x2520) (#xA8B8 #x252F) (#xA8B9 #x2528) (#xA8BA #x2537) (#xA8BB #x253F) (#xA8BC #x251D) (#xA8BD #x2530) (#xA8BE #x2525) (#xA8BF #x2538) (#xA8C0 #x2542) (#xB0A1 #x4E9C) (#xB0A2 #x5516) (#xB0A3 #x5A03) (#xB0A4 #x963F) (#xB0A5 #x54C0) (#xB0A6 #x611B) (#xB0A7 #x6328) (#xB0A8 #x59F6) (#xB0A9 #x9022) (#xB0AA #x8475) (#xB0AB #x831C) (#xB0AC #x7A50) (#xB0AD #x60AA) (#xB0AE #x63E1) (#xB0AF #x6E25) (#xB0B0 #x65ED) (#xB0B1 #x8466) (#xB0B2 #x82A6) (#xB0B3 #x9BF5) (#xB0B4 #x6893) (#xB0B5 #x5727) (#xB0B6 #x65A1) (#xB0B7 #x6271) (#xB0B8 #x5B9B) (#xB0B9 #x59D0) (#xB0BA #x867B) (#xB0BB #x98F4) (#xB0BC #x7D62) (#xB0BD #x7DBE) (#xB0BE #x9B8E) (#xB0BF #x6216) (#xB0C0 #x7C9F) (#xB0C1 #x88B7) (#xB0C2 #x5B89) (#xB0C3 #x5EB5) (#xB0C4 #x6309) (#xB0C5 #x6697) (#xB0C6 #x6848) (#xB0C7 #x95C7) (#xB0C8 #x978D) (#xB0C9 #x674F) (#xB0CA #x4EE5) (#xB0CB #x4F0A) (#xB0CC #x4F4D) (#xB0CD #x4F9D) (#xB0CE #x5049) (#xB0CF #x56F2) (#xB0D0 #x5937) (#xB0D1 #x59D4) (#xB0D2 #x5A01) (#xB0D3 #x5C09) (#xB0D4 #x60DF) (#xB0D5 #x610F) (#xB0D6 #x6170) (#xB0D7 #x6613) (#xB0D8 #x6905) (#xB0D9 #x70BA) (#xB0DA #x754F) (#xB0DB #x7570) (#xB0DC #x79FB) (#xB0DD #x7DAD) (#xB0DE #x7DEF) (#xB0DF #x80C3) (#xB0E0 #x840E) (#xB0E1 #x8863) (#xB0E2 #x8B02) (#xB0E3 #x9055) (#xB0E4 #x907A) (#xB0E5 #x533B) (#xB0E6 #x4E95) (#xB0E7 #x4EA5) (#xB0E8 #x57DF) (#xB0E9 #x80B2) (#xB0EA #x90C1) (#xB0EB #x78EF) (#xB0EC #x4E00) (#xB0ED #x58F1) (#xB0EE #x6EA2) (#xB0EF #x9038) (#xB0F0 #x7A32) (#xB0F1 #x8328) (#xB0F2 #x828B) (#xB0F3 #x9C2F) (#xB0F4 #x5141) (#xB0F5 #x5370) (#xB0F6 #x54BD) (#xB0F7 #x54E1) (#xB0F8 #x56E0) (#xB0F9 #x59FB) (#xB0FA #x5F15) (#xB0FB #x98F2) (#xB0FC #x6DEB) (#xB0FD #x80E4) (#xB0FE #x852D) (#xB1A1 #x9662) (#xB1A2 #x9670) (#xB1A3 #x96A0) (#xB1A4 #x97FB) (#xB1A5 #x540B) (#xB1A6 #x53F3) (#xB1A7 #x5B87) (#xB1A8 #x70CF) (#xB1A9 #x7FBD) (#xB1AA #x8FC2) (#xB1AB #x96E8) (#xB1AC #x536F) (#xB1AD #x9D5C) (#xB1AE #x7ABA) (#xB1AF #x4E11) (#xB1B0 #x7893) (#xB1B1 #x81FC) (#xB1B2 #x6E26) (#xB1B3 #x5618) (#xB1B4 #x5504) (#xB1B5 #x6B1D) (#xB1B6 #x851A) (#xB1B7 #x9C3B) (#xB1B8 #x59E5) (#xB1B9 #x53A9) (#xB1BA #x6D66) (#xB1BB #x74DC) (#xB1BC #x958F) (#xB1BD #x5642) (#xB1BE #x4E91) (#xB1BF #x904B) (#xB1C0 #x96F2) (#xB1C1 #x834F) (#xB1C2 #x990C) (#xB1C3 #x53E1) (#xB1C4 #x55B6) (#xB1C5 #x5B30) (#xB1C6 #x5F71) (#xB1C7 #x6620) (#xB1C8 #x66F3) (#xB1C9 #x6804) (#xB1CA #x6C38) (#xB1CB #x6CF3) (#xB1CC #x6D29) (#xB1CD #x745B) (#xB1CE #x76C8) (#xB1CF #x7A4E) (#xB1D0 #x9834) (#xB1D1 #x82F1) (#xB1D2 #x885B) (#xB1D3 #x8A60) (#xB1D4 #x92ED) (#xB1D5 #x6DB2) (#xB1D6 #x75AB) (#xB1D7 #x76CA) (#xB1D8 #x99C5) (#xB1D9 #x60A6) (#xB1DA #x8B01) (#xB1DB #x8D8A) (#xB1DC #x95B2) (#xB1DD #x698E) (#xB1DE #x53AD) (#xB1DF #x5186) (#xB1E0 #x5712) (#xB1E1 #x5830) (#xB1E2 #x5944) (#xB1E3 #x5BB4) (#xB1E4 #x5EF6) (#xB1E5 #x6028) (#xB1E6 #x63A9) (#xB1E7 #x63F4) (#xB1E8 #x6CBF) (#xB1E9 #x6F14) (#xB1EA #x708E) (#xB1EB #x7114) (#xB1EC #x7159) (#xB1ED #x71D5) (#xB1EE #x733F) (#xB1EF #x7E01) (#xB1F0 #x8276) (#xB1F1 #x82D1) (#xB1F2 #x8597) (#xB1F3 #x9060) (#xB1F4 #x925B) (#xB1F5 #x9D1B) (#xB1F6 #x5869) (#xB1F7 #x65BC) (#xB1F8 #x6C5A) (#xB1F9 #x7525) (#xB1FA #x51F9) (#xB1FB #x592E) (#xB1FC #x5965) (#xB1FD #x5F80) (#xB1FE #x5FDC) (#xB2A1 #x62BC) (#xB2A2 #x65FA) (#xB2A3 #x6A2A) (#xB2A4 #x6B27) (#xB2A5 #x6BB4) (#xB2A6 #x738B) (#xB2A7 #x7FC1) (#xB2A8 #x8956) (#xB2A9 #x9D2C) (#xB2AA #x9D0E) (#xB2AB #x9EC4) (#xB2AC #x5CA1) (#xB2AD #x6C96) (#xB2AE #x837B) (#xB2AF #x5104) (#xB2B0 #x5C4B) (#xB2B1 #x61B6) (#xB2B2 #x81C6) (#xB2B3 #x6876) (#xB2B4 #x7261) (#xB2B5 #x4E59) (#xB2B6 #x4FFA) (#xB2B7 #x5378) (#xB2B8 #x6069) (#xB2B9 #x6E29) (#xB2BA #x7A4F) (#xB2BB #x97F3) (#xB2BC #x4E0B) (#xB2BD #x5316) (#xB2BE #x4EEE) (#xB2BF #x4F55) (#xB2C0 #x4F3D) (#xB2C1 #x4FA1) (#xB2C2 #x4F73) (#xB2C3 #x52A0) (#xB2C4 #x53EF) (#xB2C5 #x5609) (#xB2C6 #x590F) (#xB2C7 #x5AC1) (#xB2C8 #x5BB6) (#xB2C9 #x5BE1) (#xB2CA #x79D1) (#xB2CB #x6687) (#xB2CC #x679C) (#xB2CD #x67B6) (#xB2CE #x6B4C) (#xB2CF #x6CB3) (#xB2D0 #x706B) (#xB2D1 #x73C2) (#xB2D2 #x798D) (#xB2D3 #x79BE) (#xB2D4 #x7A3C) (#xB2D5 #x7B87) (#xB2D6 #x82B1) (#xB2D7 #x82DB) (#xB2D8 #x8304) (#xB2D9 #x8377) (#xB2DA #x83EF) (#xB2DB #x83D3) (#xB2DC #x8766) (#xB2DD #x8AB2) (#xB2DE #x5629) (#xB2DF #x8CA8) (#xB2E0 #x8FE6) (#xB2E1 #x904E) (#xB2E2 #x971E) (#xB2E3 #x868A) (#xB2E4 #x4FC4) (#xB2E5 #x5CE8) (#xB2E6 #x6211) (#xB2E7 #x7259) (#xB2E8 #x753B) (#xB2E9 #x81E5) (#xB2EA #x82BD) (#xB2EB #x86FE) (#xB2EC #x8CC0) (#xB2ED #x96C5) (#xB2EE #x9913) (#xB2EF #x99D5) (#xB2F0 #x4ECB) (#xB2F1 #x4F1A) (#xB2F2 #x89E3) (#xB2F3 #x56DE) (#xB2F4 #x584A) (#xB2F5 #x58CA) (#xB2F6 #x5EFB) (#xB2F7 #x5FEB) (#xB2F8 #x602A) (#xB2F9 #x6094) (#xB2FA #x6062) (#xB2FB #x61D0) (#xB2FC #x6212) (#xB2FD #x62D0) (#xB2FE #x6539) (#xB3A1 #x9B41) (#xB3A2 #x6666) (#xB3A3 #x68B0) (#xB3A4 #x6D77) (#xB3A5 #x7070) (#xB3A6 #x754C) (#xB3A7 #x7686) (#xB3A8 #x7D75) (#xB3A9 #x82A5) (#xB3AA #x87F9) (#xB3AB #x958B) (#xB3AC #x968E) (#xB3AD #x8C9D) (#xB3AE #x51F1) (#xB3AF #x52BE) (#xB3B0 #x5916) (#xB3B1 #x54B3) (#xB3B2 #x5BB3) (#xB3B3 #x5D16) (#xB3B4 #x6168) (#xB3B5 #x6982) (#xB3B6 #x6DAF) (#xB3B7 #x788D) (#xB3B8 #x84CB) (#xB3B9 #x8857) (#xB3BA #x8A72) (#xB3BB #x93A7) (#xB3BC #x9AB8) (#xB3BD #x6D6C) (#xB3BE #x99A8) (#xB3BF #x86D9) (#xB3C0 #x57A3) (#xB3C1 #x67FF) (#xB3C2 #x86CE) (#xB3C3 #x920E) (#xB3C4 #x5283) (#xB3C5 #x5687) (#xB3C6 #x5404) (#xB3C7 #x5ED3) (#xB3C8 #x62E1) (#xB3C9 #x64B9) (#xB3CA #x683C) (#xB3CB #x6838) (#xB3CC #x6BBB) (#xB3CD #x7372) (#xB3CE #x78BA) (#xB3CF #x7A6B) (#xB3D0 #x899A) (#xB3D1 #x89D2) (#xB3D2 #x8D6B) (#xB3D3 #x8F03) (#xB3D4 #x90ED) (#xB3D5 #x95A3) (#xB3D6 #x9694) (#xB3D7 #x9769) (#xB3D8 #x5B66) (#xB3D9 #x5CB3) (#xB3DA #x697D) (#xB3DB #x984D) (#xB3DC #x984E) (#xB3DD #x639B) (#xB3DE #x7B20) (#xB3DF #x6A2B) (#xB3E0 #x6A7F) (#xB3E1 #x68B6) (#xB3E2 #x9C0D) (#xB3E3 #x6F5F) (#xB3E4 #x5272) (#xB3E5 #x559D) (#xB3E6 #x6070) (#xB3E7 #x62EC) (#xB3E8 #x6D3B) (#xB3E9 #x6E07) (#xB3EA #x6ED1) (#xB3EB #x845B) (#xB3EC #x8910) (#xB3ED #x8F44) (#xB3EE #x4E14) (#xB3EF #x9C39) (#xB3F0 #x53F6) (#xB3F1 #x691B) (#xB3F2 #x6A3A) (#xB3F3 #x9784) (#xB3F4 #x682A) (#xB3F5 #x515C) (#xB3F6 #x7AC3) (#xB3F7 #x84B2) (#xB3F8 #x91DC) (#xB3F9 #x938C) (#xB3FA #x565B) (#xB3FB #x9D28) (#xB3FC #x6822) (#xB3FD #x8305) (#xB3FE #x8431) (#xB4A1 #x7CA5) (#xB4A2 #x5208) (#xB4A3 #x82C5) (#xB4A4 #x74E6) (#xB4A5 #x4E7E) (#xB4A6 #x4F83) (#xB4A7 #x51A0) (#xB4A8 #x5BD2) (#xB4A9 #x520A) (#xB4AA #x52D8) (#xB4AB #x52E7) (#xB4AC #x5DFB) (#xB4AD #x559A) (#xB4AE #x582A) (#xB4AF #x59E6) (#xB4B0 #x5B8C) (#xB4B1 #x5B98) (#xB4B2 #x5BDB) (#xB4B3 #x5E72) (#xB4B4 #x5E79) (#xB4B5 #x60A3) (#xB4B6 #x611F) (#xB4B7 #x6163) (#xB4B8 #x61BE) (#xB4B9 #x63DB) (#xB4BA #x6562) (#xB4BB #x67D1) (#xB4BC #x6853) (#xB4BD #x68FA) (#xB4BE #x6B3E) (#xB4BF #x6B53) (#xB4C0 #x6C57) (#xB4C1 #x6F22) (#xB4C2 #x6F97) (#xB4C3 #x6F45) (#xB4C4 #x74B0) (#xB4C5 #x7518) (#xB4C6 #x76E3) (#xB4C7 #x770B) (#xB4C8 #x7AFF) (#xB4C9 #x7BA1) (#xB4CA #x7C21) (#xB4CB #x7DE9) (#xB4CC #x7F36) (#xB4CD #x7FF0) (#xB4CE #x809D) (#xB4CF #x8266) (#xB4D0 #x839E) (#xB4D1 #x89B3) (#xB4D2 #x8ACC) (#xB4D3 #x8CAB) (#xB4D4 #x9084) (#xB4D5 #x9451) (#xB4D6 #x9593) (#xB4D7 #x9591) (#xB4D8 #x95A2) (#xB4D9 #x9665) (#xB4DA #x97D3) (#xB4DB #x9928) (#xB4DC #x8218) (#xB4DD #x4E38) (#xB4DE #x542B) (#xB4DF #x5CB8) (#xB4E0 #x5DCC) (#xB4E1 #x73A9) (#xB4E2 #x764C) (#xB4E3 #x773C) (#xB4E4 #x5CA9) (#xB4E5 #x7FEB) (#xB4E6 #x8D0B) (#xB4E7 #x96C1) (#xB4E8 #x9811) (#xB4E9 #x9854) (#xB4EA #x9858) (#xB4EB #x4F01) (#xB4EC #x4F0E) (#xB4ED #x5371) (#xB4EE #x559C) (#xB4EF #x5668) (#xB4F0 #x57FA) (#xB4F1 #x5947) (#xB4F2 #x5B09) (#xB4F3 #x5BC4) (#xB4F4 #x5C90) (#xB4F5 #x5E0C) (#xB4F6 #x5E7E) (#xB4F7 #x5FCC) (#xB4F8 #x63EE) (#xB4F9 #x673A) (#xB4FA #x65D7) (#xB4FB #x65E2) (#xB4FC #x671F) (#xB4FD #x68CB) (#xB4FE #x68C4) (#xB5A1 #x6A5F) (#xB5A2 #x5E30) (#xB5A3 #x6BC5) (#xB5A4 #x6C17) (#xB5A5 #x6C7D) (#xB5A6 #x757F) (#xB5A7 #x7948) (#xB5A8 #x5B63) (#xB5A9 #x7A00) (#xB5AA #x7D00) (#xB5AB #x5FBD) (#xB5AC #x898F) (#xB5AD #x8A18) (#xB5AE #x8CB4) (#xB5AF #x8D77) (#xB5B0 #x8ECC) (#xB5B1 #x8F1D) (#xB5B2 #x98E2) (#xB5B3 #x9A0E) (#xB5B4 #x9B3C) (#xB5B5 #x4E80) (#xB5B6 #x507D) (#xB5B7 #x5100) (#xB5B8 #x5993) (#xB5B9 #x5B9C) (#xB5BA #x622F) (#xB5BB #x6280) (#xB5BC #x64EC) (#xB5BD #x6B3A) (#xB5BE #x72A0) (#xB5BF #x7591) (#xB5C0 #x7947) (#xB5C1 #x7FA9) (#xB5C2 #x87FB) (#xB5C3 #x8ABC) (#xB5C4 #x8B70) (#xB5C5 #x63AC) (#xB5C6 #x83CA) (#xB5C7 #x97A0) (#xB5C8 #x5409) (#xB5C9 #x5403) (#xB5CA #x55AB) (#xB5CB #x6854) (#xB5CC #x6A58) (#xB5CD #x8A70) (#xB5CE #x7827) (#xB5CF #x6775) (#xB5D0 #x9ECD) (#xB5D1 #x5374) (#xB5D2 #x5BA2) (#xB5D3 #x811A) (#xB5D4 #x8650) (#xB5D5 #x9006) (#xB5D6 #x4E18) (#xB5D7 #x4E45) (#xB5D8 #x4EC7) (#xB5D9 #x4F11) (#xB5DA #x53CA) (#xB5DB #x5438) (#xB5DC #x5BAE) (#xB5DD #x5F13) (#xB5DE #x6025) (#xB5DF #x6551) (#xB5E0 #x673D) (#xB5E1 #x6C42) (#xB5E2 #x6C72) (#xB5E3 #x6CE3) (#xB5E4 #x7078) (#xB5E5 #x7403) (#xB5E6 #x7A76) (#xB5E7 #x7AAE) (#xB5E8 #x7B08) (#xB5E9 #x7D1A) (#xB5EA #x7CFE) (#xB5EB #x7D66) (#xB5EC #x65E7) (#xB5ED #x725B) (#xB5EE #x53BB) (#xB5EF #x5C45) (#xB5F0 #x5DE8) (#xB5F1 #x62D2) (#xB5F2 #x62E0) (#xB5F3 #x6319) (#xB5F4 #x6E20) (#xB5F5 #x865A) (#xB5F6 #x8A31) (#xB5F7 #x8DDD) (#xB5F8 #x92F8) (#xB5F9 #x6F01) (#xB5FA #x79A6) (#xB5FB #x9B5A) (#xB5FC #x4EA8) (#xB5FD #x4EAB) (#xB5FE #x4EAC) (#xB6A1 #x4F9B) (#xB6A2 #x4FA0) (#xB6A3 #x50D1) (#xB6A4 #x5147) (#xB6A5 #x7AF6) (#xB6A6 #x5171) (#xB6A7 #x51F6) (#xB6A8 #x5354) (#xB6A9 #x5321) (#xB6AA #x537F) (#xB6AB #x53EB) (#xB6AC #x55AC) (#xB6AD #x5883) (#xB6AE #x5CE1) (#xB6AF #x5F37) (#xB6B0 #x5F4A) (#xB6B1 #x602F) (#xB6B2 #x6050) (#xB6B3 #x606D) (#xB6B4 #x631F) (#xB6B5 #x6559) (#xB6B6 #x6A4B) (#xB6B7 #x6CC1) (#xB6B8 #x72C2) (#xB6B9 #x72ED) (#xB6BA #x77EF) (#xB6BB #x80F8) (#xB6BC #x8105) (#xB6BD #x8208) (#xB6BE #x854E) (#xB6BF #x90F7) (#xB6C0 #x93E1) (#xB6C1 #x97FF) (#xB6C2 #x9957) (#xB6C3 #x9A5A) (#xB6C4 #x4EF0) (#xB6C5 #x51DD) (#xB6C6 #x5C2D) (#xB6C7 #x6681) (#xB6C8 #x696D) (#xB6C9 #x5C40) (#xB6CA #x66F2) (#xB6CB #x6975) (#xB6CC #x7389) (#xB6CD #x6850) (#xB6CE #x7C81) (#xB6CF #x50C5) (#xB6D0 #x52E4) (#xB6D1 #x5747) (#xB6D2 #x5DFE) (#xB6D3 #x9326) (#xB6D4 #x65A4) (#xB6D5 #x6B23) (#xB6D6 #x6B3D) (#xB6D7 #x7434) (#xB6D8 #x7981) (#xB6D9 #x79BD) (#xB6DA #x7B4B) (#xB6DB #x7DCA) (#xB6DC #x82B9) (#xB6DD #x83CC) (#xB6DE #x887F) (#xB6DF #x895F) (#xB6E0 #x8B39) (#xB6E1 #x8FD1) (#xB6E2 #x91D1) (#xB6E3 #x541F) (#xB6E4 #x9280) (#xB6E5 #x4E5D) (#xB6E6 #x5036) (#xB6E7 #x53E5) (#xB6E8 #x533A) (#xB6E9 #x72D7) (#xB6EA #x7396) (#xB6EB #x77E9) (#xB6EC #x82E6) (#xB6ED #x8EAF) (#xB6EE #x99C6) (#xB6EF #x99C8) (#xB6F0 #x99D2) (#xB6F1 #x5177) (#xB6F2 #x611A) (#xB6F3 #x865E) (#xB6F4 #x55B0) (#xB6F5 #x7A7A) (#xB6F6 #x5076) (#xB6F7 #x5BD3) (#xB6F8 #x9047) (#xB6F9 #x9685) (#xB6FA #x4E32) (#xB6FB #x6ADB) (#xB6FC #x91E7) (#xB6FD #x5C51) (#xB6FE #x5C48) (#xB7A1 #x6398) (#xB7A2 #x7A9F) (#xB7A3 #x6C93) (#xB7A4 #x9774) (#xB7A5 #x8F61) (#xB7A6 #x7AAA) (#xB7A7 #x718A) (#xB7A8 #x9688) (#xB7A9 #x7C82) (#xB7AA #x6817) (#xB7AB #x7E70) (#xB7AC #x6851) (#xB7AD #x936C) (#xB7AE #x52F2) (#xB7AF #x541B) (#xB7B0 #x85AB) (#xB7B1 #x8A13) (#xB7B2 #x7FA4) (#xB7B3 #x8ECD) (#xB7B4 #x90E1) (#xB7B5 #x5366) (#xB7B6 #x8888) (#xB7B7 #x7941) (#xB7B8 #x4FC2) (#xB7B9 #x50BE) (#xB7BA #x5211) (#xB7BB #x5144) (#xB7BC #x5553) (#xB7BD #x572D) (#xB7BE #x73EA) (#xB7BF #x578B) (#xB7C0 #x5951) (#xB7C1 #x5F62) (#xB7C2 #x5F84) (#xB7C3 #x6075) (#xB7C4 #x6176) (#xB7C5 #x6167) (#xB7C6 #x61A9) (#xB7C7 #x63B2) (#xB7C8 #x643A) (#xB7C9 #x656C) (#xB7CA #x666F) (#xB7CB #x6842) (#xB7CC #x6E13) (#xB7CD #x7566) (#xB7CE #x7A3D) (#xB7CF #x7CFB) (#xB7D0 #x7D4C) (#xB7D1 #x7D99) (#xB7D2 #x7E4B) (#xB7D3 #x7F6B) (#xB7D4 #x830E) (#xB7D5 #x834A) (#xB7D6 #x86CD) (#xB7D7 #x8A08) (#xB7D8 #x8A63) (#xB7D9 #x8B66) (#xB7DA #x8EFD) (#xB7DB #x981A) (#xB7DC #x9D8F) (#xB7DD #x82B8) (#xB7DE #x8FCE) (#xB7DF #x9BE8) (#xB7E0 #x5287) (#xB7E1 #x621F) (#xB7E2 #x6483) (#xB7E3 #x6FC0) (#xB7E4 #x9699) (#xB7E5 #x6841) (#xB7E6 #x5091) (#xB7E7 #x6B20) (#xB7E8 #x6C7A) (#xB7E9 #x6F54) (#xB7EA #x7A74) (#xB7EB #x7D50) (#xB7EC #x8840) (#xB7ED #x8A23) (#xB7EE #x6708) (#xB7EF #x4EF6) (#xB7F0 #x5039) (#xB7F1 #x5026) (#xB7F2 #x5065) (#xB7F3 #x517C) (#xB7F4 #x5238) (#xB7F5 #x5263) (#xB7F6 #x55A7) (#xB7F7 #x570F) (#xB7F8 #x5805) (#xB7F9 #x5ACC) (#xB7FA #x5EFA) (#xB7FB #x61B2) (#xB7FC #x61F8) (#xB7FD #x62F3) (#xB7FE #x6372) (#xB8A1 #x691C) (#xB8A2 #x6A29) (#xB8A3 #x727D) (#xB8A4 #x72AC) (#xB8A5 #x732E) (#xB8A6 #x7814) (#xB8A7 #x786F) (#xB8A8 #x7D79) (#xB8A9 #x770C) (#xB8AA #x80A9) (#xB8AB #x898B) (#xB8AC #x8B19) (#xB8AD #x8CE2) (#xB8AE #x8ED2) (#xB8AF #x9063) (#xB8B0 #x9375) (#xB8B1 #x967A) (#xB8B2 #x9855) (#xB8B3 #x9A13) (#xB8B4 #x9E78) (#xB8B5 #x5143) (#xB8B6 #x539F) (#xB8B7 #x53B3) (#xB8B8 #x5E7B) (#xB8B9 #x5F26) (#xB8BA #x6E1B) (#xB8BB #x6E90) (#xB8BC #x7384) (#xB8BD #x73FE) (#xB8BE #x7D43) (#xB8BF #x8237) (#xB8C0 #x8A00) (#xB8C1 #x8AFA) (#xB8C2 #x9650) (#xB8C3 #x4E4E) (#xB8C4 #x500B) (#xB8C5 #x53E4) (#xB8C6 #x547C) (#xB8C7 #x56FA) (#xB8C8 #x59D1) (#xB8C9 #x5B64) (#xB8CA #x5DF1) (#xB8CB #x5EAB) (#xB8CC #x5F27) (#xB8CD #x6238) (#xB8CE #x6545) (#xB8CF #x67AF) (#xB8D0 #x6E56) (#xB8D1 #x72D0) (#xB8D2 #x7CCA) (#xB8D3 #x88B4) (#xB8D4 #x80A1) (#xB8D5 #x80E1) (#xB8D6 #x83F0) (#xB8D7 #x864E) (#xB8D8 #x8A87) (#xB8D9 #x8DE8) (#xB8DA #x9237) (#xB8DB #x96C7) (#xB8DC #x9867) (#xB8DD #x9F13) (#xB8DE #x4E94) (#xB8DF #x4E92) (#xB8E0 #x4F0D) (#xB8E1 #x5348) (#xB8E2 #x5449) (#xB8E3 #x543E) (#xB8E4 #x5A2F) (#xB8E5 #x5F8C) (#xB8E6 #x5FA1) (#xB8E7 #x609F) (#xB8E8 #x68A7) (#xB8E9 #x6A8E) (#xB8EA #x745A) (#xB8EB #x7881) (#xB8EC #x8A9E) (#xB8ED #x8AA4) (#xB8EE #x8B77) (#xB8EF #x9190) (#xB8F0 #x4E5E) (#xB8F1 #x9BC9) (#xB8F2 #x4EA4) (#xB8F3 #x4F7C) (#xB8F4 #x4FAF) (#xB8F5 #x5019) (#xB8F6 #x5016) (#xB8F7 #x5149) (#xB8F8 #x516C) (#xB8F9 #x529F) (#xB8FA #x52B9) (#xB8FB #x52FE) (#xB8FC #x539A) (#xB8FD #x53E3) (#xB8FE #x5411) (#xB9A1 #x540E) (#xB9A2 #x5589) (#xB9A3 #x5751) (#xB9A4 #x57A2) (#xB9A5 #x597D) (#xB9A6 #x5B54) (#xB9A7 #x5B5D) (#xB9A8 #x5B8F) (#xB9A9 #x5DE5) (#xB9AA #x5DE7) (#xB9AB #x5DF7) (#xB9AC #x5E78) (#xB9AD #x5E83) (#xB9AE #x5E9A) (#xB9AF #x5EB7) (#xB9B0 #x5F18) (#xB9B1 #x6052) (#xB9B2 #x614C) (#xB9B3 #x6297) (#xB9B4 #x62D8) (#xB9B5 #x63A7) (#xB9B6 #x653B) (#xB9B7 #x6602) (#xB9B8 #x6643) (#xB9B9 #x66F4) (#xB9BA #x676D) (#xB9BB #x6821) (#xB9BC #x6897) (#xB9BD #x69CB) (#xB9BE #x6C5F) (#xB9BF #x6D2A) (#xB9C0 #x6D69) (#xB9C1 #x6E2F) (#xB9C2 #x6E9D) (#xB9C3 #x7532) (#xB9C4 #x7687) (#xB9C5 #x786C) (#xB9C6 #x7A3F) (#xB9C7 #x7CE0) (#xB9C8 #x7D05) (#xB9C9 #x7D18) (#xB9CA #x7D5E) (#xB9CB #x7DB1) (#xB9CC #x8015) (#xB9CD #x8003) (#xB9CE #x80AF) (#xB9CF #x80B1) (#xB9D0 #x8154) (#xB9D1 #x818F) (#xB9D2 #x822A) (#xB9D3 #x8352) (#xB9D4 #x884C) (#xB9D5 #x8861) (#xB9D6 #x8B1B) (#xB9D7 #x8CA2) (#xB9D8 #x8CFC) (#xB9D9 #x90CA) (#xB9DA #x9175) (#xB9DB #x9271) (#xB9DC #x783F) (#xB9DD #x92FC) (#xB9DE #x95A4) (#xB9DF #x964D) (#xB9E0 #x9805) (#xB9E1 #x9999) (#xB9E2 #x9AD8) (#xB9E3 #x9D3B) (#xB9E4 #x525B) (#xB9E5 #x52AB) (#xB9E6 #x53F7) (#xB9E7 #x5408) (#xB9E8 #x58D5) (#xB9E9 #x62F7) (#xB9EA #x6FE0) (#xB9EB #x8C6A) (#xB9EC #x8F5F) (#xB9ED #x9EB9) (#xB9EE #x514B) (#xB9EF #x523B) (#xB9F0 #x544A) (#xB9F1 #x56FD) (#xB9F2 #x7A40) (#xB9F3 #x9177) (#xB9F4 #x9D60) (#xB9F5 #x9ED2) (#xB9F6 #x7344) (#xB9F7 #x6F09) (#xB9F8 #x8170) (#xB9F9 #x7511) (#xB9FA #x5FFD) (#xB9FB #x60DA) (#xB9FC #x9AA8) (#xB9FD #x72DB) (#xB9FE #x8FBC) (#xBAA1 #x6B64) (#xBAA2 #x9803) (#xBAA3 #x4ECA) (#xBAA4 #x56F0) (#xBAA5 #x5764) (#xBAA6 #x58BE) (#xBAA7 #x5A5A) (#xBAA8 #x6068) (#xBAA9 #x61C7) (#xBAAA #x660F) (#xBAAB #x6606) (#xBAAC #x6839) (#xBAAD #x68B1) (#xBAAE #x6DF7) (#xBAAF #x75D5) (#xBAB0 #x7D3A) (#xBAB1 #x826E) (#xBAB2 #x9B42) (#xBAB3 #x4E9B) (#xBAB4 #x4F50) (#xBAB5 #x53C9) (#xBAB6 #x5506) (#xBAB7 #x5D6F) (#xBAB8 #x5DE6) (#xBAB9 #x5DEE) (#xBABA #x67FB) (#xBABB #x6C99) (#xBABC #x7473) (#xBABD #x7802) (#xBABE #x8A50) (#xBABF #x9396) (#xBAC0 #x88DF) (#xBAC1 #x5750) (#xBAC2 #x5EA7) (#xBAC3 #x632B) (#xBAC4 #x50B5) (#xBAC5 #x50AC) (#xBAC6 #x518D) (#xBAC7 #x6700) (#xBAC8 #x54C9) (#xBAC9 #x585E) (#xBACA #x59BB) (#xBACB #x5BB0) (#xBACC #x5F69) (#xBACD #x624D) (#xBACE #x63A1) (#xBACF #x683D) (#xBAD0 #x6B73) (#xBAD1 #x6E08) (#xBAD2 #x707D) (#xBAD3 #x91C7) (#xBAD4 #x7280) (#xBAD5 #x7815) (#xBAD6 #x7826) (#xBAD7 #x796D) (#xBAD8 #x658E) (#xBAD9 #x7D30) (#xBADA #x83DC) (#xBADB #x88C1) (#xBADC #x8F09) (#xBADD #x969B) (#xBADE #x5264) (#xBADF #x5728) (#xBAE0 #x6750) (#xBAE1 #x7F6A) (#xBAE2 #x8CA1) (#xBAE3 #x51B4) (#xBAE4 #x5742) (#xBAE5 #x962A) (#xBAE6 #x583A) (#xBAE7 #x698A) (#xBAE8 #x80B4) (#xBAE9 #x54B2) (#xBAEA #x5D0E) (#xBAEB #x57FC) (#xBAEC #x7895) (#xBAED #x9DFA) (#xBAEE #x4F5C) (#xBAEF #x524A) (#xBAF0 #x548B) (#xBAF1 #x643E) (#xBAF2 #x6628) (#xBAF3 #x6714) (#xBAF4 #x67F5) (#xBAF5 #x7A84) (#xBAF6 #x7B56) (#xBAF7 #x7D22) (#xBAF8 #x932F) (#xBAF9 #x685C) (#xBAFA #x9BAD) (#xBAFB #x7B39) (#xBAFC #x5319) (#xBAFD #x518A) (#xBAFE #x5237) (#xBBA1 #x5BDF) (#xBBA2 #x62F6) (#xBBA3 #x64AE) (#xBBA4 #x64E6) (#xBBA5 #x672D) (#xBBA6 #x6BBA) (#xBBA7 #x85A9) (#xBBA8 #x96D1) (#xBBA9 #x7690) (#xBBAA #x9BD6) (#xBBAB #x634C) (#xBBAC #x9306) (#xBBAD #x9BAB) (#xBBAE #x76BF) (#xBBAF #x6652) (#xBBB0 #x4E09) (#xBBB1 #x5098) (#xBBB2 #x53C2) (#xBBB3 #x5C71) (#xBBB4 #x60E8) (#xBBB5 #x6492) (#xBBB6 #x6563) (#xBBB7 #x685F) (#xBBB8 #x71E6) (#xBBB9 #x73CA) (#xBBBA #x7523) (#xBBBB #x7B97) (#xBBBC #x7E82) (#xBBBD #x8695) (#xBBBE #x8B83) (#xBBBF #x8CDB) (#xBBC0 #x9178) (#xBBC1 #x9910) (#xBBC2 #x65AC) (#xBBC3 #x66AB) (#xBBC4 #x6B8B) (#xBBC5 #x4ED5) (#xBBC6 #x4ED4) (#xBBC7 #x4F3A) (#xBBC8 #x4F7F) (#xBBC9 #x523A) (#xBBCA #x53F8) (#xBBCB #x53F2) (#xBBCC #x55E3) (#xBBCD #x56DB) (#xBBCE #x58EB) (#xBBCF #x59CB) (#xBBD0 #x59C9) (#xBBD1 #x59FF) (#xBBD2 #x5B50) (#xBBD3 #x5C4D) (#xBBD4 #x5E02) (#xBBD5 #x5E2B) (#xBBD6 #x5FD7) (#xBBD7 #x601D) (#xBBD8 #x6307) (#xBBD9 #x652F) (#xBBDA #x5B5C) (#xBBDB #x65AF) (#xBBDC #x65BD) (#xBBDD #x65E8) (#xBBDE #x679D) (#xBBDF #x6B62) (#xBBE0 #x6B7B) (#xBBE1 #x6C0F) (#xBBE2 #x7345) (#xBBE3 #x7949) (#xBBE4 #x79C1) (#xBBE5 #x7CF8) (#xBBE6 #x7D19) (#xBBE7 #x7D2B) (#xBBE8 #x80A2) (#xBBE9 #x8102) (#xBBEA #x81F3) (#xBBEB #x8996) (#xBBEC #x8A5E) (#xBBED #x8A69) (#xBBEE #x8A66) (#xBBEF #x8A8C) (#xBBF0 #x8AEE) (#xBBF1 #x8CC7) (#xBBF2 #x8CDC) (#xBBF3 #x96CC) (#xBBF4 #x98FC) (#xBBF5 #x6B6F) (#xBBF6 #x4E8B) (#xBBF7 #x4F3C) (#xBBF8 #x4F8D) (#xBBF9 #x5150) (#xBBFA #x5B57) (#xBBFB #x5BFA) (#xBBFC #x6148) (#xBBFD #x6301) (#xBBFE #x6642) (#xBCA1 #x6B21) (#xBCA2 #x6ECB) (#xBCA3 #x6CBB) (#xBCA4 #x723E) (#xBCA5 #x74BD) (#xBCA6 #x75D4) (#xBCA7 #x78C1) (#xBCA8 #x793A) (#xBCA9 #x800C) (#xBCAA #x8033) (#xBCAB #x81EA) (#xBCAC #x8494) (#xBCAD #x8F9E) (#xBCAE #x6C50) (#xBCAF #x9E7F) (#xBCB0 #x5F0F) (#xBCB1 #x8B58) (#xBCB2 #x9D2B) (#xBCB3 #x7AFA) (#xBCB4 #x8EF8) (#xBCB5 #x5B8D) (#xBCB6 #x96EB) (#xBCB7 #x4E03) (#xBCB8 #x53F1) (#xBCB9 #x57F7) (#xBCBA #x5931) (#xBCBB #x5AC9) (#xBCBC #x5BA4) (#xBCBD #x6089) (#xBCBE #x6E7F) (#xBCBF #x6F06) (#xBCC0 #x75BE) (#xBCC1 #x8CEA) (#xBCC2 #x5B9F) (#xBCC3 #x8500) (#xBCC4 #x7BE0) (#xBCC5 #x5072) (#xBCC6 #x67F4) (#xBCC7 #x829D) (#xBCC8 #x5C61) (#xBCC9 #x854A) (#xBCCA #x7E1E) (#xBCCB #x820E) (#xBCCC #x5199) (#xBCCD #x5C04) (#xBCCE #x6368) (#xBCCF #x8D66) (#xBCD0 #x659C) (#xBCD1 #x716E) (#xBCD2 #x793E) (#xBCD3 #x7D17) (#xBCD4 #x8005) (#xBCD5 #x8B1D) (#xBCD6 #x8ECA) (#xBCD7 #x906E) (#xBCD8 #x86C7) (#xBCD9 #x90AA) (#xBCDA #x501F) (#xBCDB #x52FA) (#xBCDC #x5C3A) (#xBCDD #x6753) (#xBCDE #x707C) (#xBCDF #x7235) (#xBCE0 #x914C) (#xBCE1 #x91C8) (#xBCE2 #x932B) (#xBCE3 #x82E5) (#xBCE4 #x5BC2) (#xBCE5 #x5F31) (#xBCE6 #x60F9) (#xBCE7 #x4E3B) (#xBCE8 #x53D6) (#xBCE9 #x5B88) (#xBCEA #x624B) (#xBCEB #x6731) (#xBCEC #x6B8A) (#xBCED #x72E9) (#xBCEE #x73E0) (#xBCEF #x7A2E) (#xBCF0 #x816B) (#xBCF1 #x8DA3) (#xBCF2 #x9152) (#xBCF3 #x9996) (#xBCF4 #x5112) (#xBCF5 #x53D7) (#xBCF6 #x546A) (#xBCF7 #x5BFF) (#xBCF8 #x6388) (#xBCF9 #x6A39) (#xBCFA #x7DAC) (#xBCFB #x9700) (#xBCFC #x56DA) (#xBCFD #x53CE) (#xBCFE #x5468) (#xBDA1 #x5B97) (#xBDA2 #x5C31) (#xBDA3 #x5DDE) (#xBDA4 #x4FEE) (#xBDA5 #x6101) (#xBDA6 #x62FE) (#xBDA7 #x6D32) (#xBDA8 #x79C0) (#xBDA9 #x79CB) (#xBDAA #x7D42) (#xBDAB #x7E4D) (#xBDAC #x7FD2) (#xBDAD #x81ED) (#xBDAE #x821F) (#xBDAF #x8490) (#xBDB0 #x8846) (#xBDB1 #x8972) (#xBDB2 #x8B90) (#xBDB3 #x8E74) (#xBDB4 #x8F2F) (#xBDB5 #x9031) (#xBDB6 #x914B) (#xBDB7 #x916C) (#xBDB8 #x96C6) (#xBDB9 #x919C) (#xBDBA #x4EC0) (#xBDBB #x4F4F) (#xBDBC #x5145) (#xBDBD #x5341) (#xBDBE #x5F93) (#xBDBF #x620E) (#xBDC0 #x67D4) (#xBDC1 #x6C41) (#xBDC2 #x6E0B) (#xBDC3 #x7363) (#xBDC4 #x7E26) (#xBDC5 #x91CD) (#xBDC6 #x9283) (#xBDC7 #x53D4) (#xBDC8 #x5919) (#xBDC9 #x5BBF) (#xBDCA #x6DD1) (#xBDCB #x795D) (#xBDCC #x7E2E) (#xBDCD #x7C9B) (#xBDCE #x587E) (#xBDCF #x719F) (#xBDD0 #x51FA) (#xBDD1 #x8853) (#xBDD2 #x8FF0) (#xBDD3 #x4FCA) (#xBDD4 #x5CFB) (#xBDD5 #x6625) (#xBDD6 #x77AC) (#xBDD7 #x7AE3) (#xBDD8 #x821C) (#xBDD9 #x99FF) (#xBDDA #x51C6) (#xBDDB #x5FAA) (#xBDDC #x65EC) (#xBDDD #x696F) (#xBDDE #x6B89) (#xBDDF #x6DF3) (#xBDE0 #x6E96) (#xBDE1 #x6F64) (#xBDE2 #x76FE) (#xBDE3 #x7D14) (#xBDE4 #x5DE1) (#xBDE5 #x9075) (#xBDE6 #x9187) (#xBDE7 #x9806) (#xBDE8 #x51E6) (#xBDE9 #x521D) (#xBDEA #x6240) (#xBDEB #x6691) (#xBDEC #x66D9) (#xBDED #x6E1A) (#xBDEE #x5EB6) (#xBDEF #x7DD2) (#xBDF0 #x7F72) (#xBDF1 #x66F8) (#xBDF2 #x85AF) (#xBDF3 #x85F7) (#xBDF4 #x8AF8) (#xBDF5 #x52A9) (#xBDF6 #x53D9) (#xBDF7 #x5973) (#xBDF8 #x5E8F) (#xBDF9 #x5F90) (#xBDFA #x6055) (#xBDFB #x92E4) (#xBDFC #x9664) (#xBDFD #x50B7) (#xBDFE #x511F) (#xBEA1 #x52DD) (#xBEA2 #x5320) (#xBEA3 #x5347) (#xBEA4 #x53EC) (#xBEA5 #x54E8) (#xBEA6 #x5546) (#xBEA7 #x5531) (#xBEA8 #x5617) (#xBEA9 #x5968) (#xBEAA #x59BE) (#xBEAB #x5A3C) (#xBEAC #x5BB5) (#xBEAD #x5C06) (#xBEAE #x5C0F) (#xBEAF #x5C11) (#xBEB0 #x5C1A) (#xBEB1 #x5E84) (#xBEB2 #x5E8A) (#xBEB3 #x5EE0) (#xBEB4 #x5F70) (#xBEB5 #x627F) (#xBEB6 #x6284) (#xBEB7 #x62DB) (#xBEB8 #x638C) (#xBEB9 #x6377) (#xBEBA #x6607) (#xBEBB #x660C) (#xBEBC #x662D) (#xBEBD #x6676) (#xBEBE #x677E) (#xBEBF #x68A2) (#xBEC0 #x6A1F) (#xBEC1 #x6A35) (#xBEC2 #x6CBC) (#xBEC3 #x6D88) (#xBEC4 #x6E09) (#xBEC5 #x6E58) (#xBEC6 #x713C) (#xBEC7 #x7126) (#xBEC8 #x7167) (#xBEC9 #x75C7) (#xBECA #x7701) (#xBECB #x785D) (#xBECC #x7901) (#xBECD #x7965) (#xBECE #x79F0) (#xBECF #x7AE0) (#xBED0 #x7B11) (#xBED1 #x7CA7) (#xBED2 #x7D39) (#xBED3 #x8096) (#xBED4 #x83D6) (#xBED5 #x848B) (#xBED6 #x8549) (#xBED7 #x885D) (#xBED8 #x88F3) (#xBED9 #x8A1F) (#xBEDA #x8A3C) (#xBEDB #x8A54) (#xBEDC #x8A73) (#xBEDD #x8C61) (#xBEDE #x8CDE) (#xBEDF #x91A4) (#xBEE0 #x9266) (#xBEE1 #x937E) (#xBEE2 #x9418) (#xBEE3 #x969C) (#xBEE4 #x9798) (#xBEE5 #x4E0A) (#xBEE6 #x4E08) (#xBEE7 #x4E1E) (#xBEE8 #x4E57) (#xBEE9 #x5197) (#xBEEA #x5270) (#xBEEB #x57CE) (#xBEEC #x5834) (#xBEED #x58CC) (#xBEEE #x5B22) (#xBEEF #x5E38) (#xBEF0 #x60C5) (#xBEF1 #x64FE) (#xBEF2 #x6761) (#xBEF3 #x6756) (#xBEF4 #x6D44) (#xBEF5 #x72B6) (#xBEF6 #x7573) (#xBEF7 #x7A63) (#xBEF8 #x84B8) (#xBEF9 #x8B72) (#xBEFA #x91B8) (#xBEFB #x9320) (#xBEFC #x5631) (#xBEFD #x57F4) (#xBEFE #x98FE) (#xBFA1 #x62ED) (#xBFA2 #x690D) (#xBFA3 #x6B96) (#xBFA4 #x71ED) (#xBFA5 #x7E54) (#xBFA6 #x8077) (#xBFA7 #x8272) (#xBFA8 #x89E6) (#xBFA9 #x98DF) (#xBFAA #x8755) (#xBFAB #x8FB1) (#xBFAC #x5C3B) (#xBFAD #x4F38) (#xBFAE #x4FE1) (#xBFAF #x4FB5) (#xBFB0 #x5507) (#xBFB1 #x5A20) (#xBFB2 #x5BDD) (#xBFB3 #x5BE9) (#xBFB4 #x5FC3) (#xBFB5 #x614E) (#xBFB6 #x632F) (#xBFB7 #x65B0) (#xBFB8 #x664B) (#xBFB9 #x68EE) (#xBFBA #x699B) (#xBFBB #x6D78) (#xBFBC #x6DF1) (#xBFBD #x7533) (#xBFBE #x75B9) (#xBFBF #x771F) (#xBFC0 #x795E) (#xBFC1 #x79E6) (#xBFC2 #x7D33) (#xBFC3 #x81E3) (#xBFC4 #x82AF) (#xBFC5 #x85AA) (#xBFC6 #x89AA) (#xBFC7 #x8A3A) (#xBFC8 #x8EAB) (#xBFC9 #x8F9B) (#xBFCA #x9032) (#xBFCB #x91DD) (#xBFCC #x9707) (#xBFCD #x4EBA) (#xBFCE #x4EC1) (#xBFCF #x5203) (#xBFD0 #x5875) (#xBFD1 #x58EC) (#xBFD2 #x5C0B) (#xBFD3 #x751A) (#xBFD4 #x5C3D) (#xBFD5 #x814E) (#xBFD6 #x8A0A) (#xBFD7 #x8FC5) (#xBFD8 #x9663) (#xBFD9 #x976D) (#xBFDA #x7B25) (#xBFDB #x8ACF) (#xBFDC #x9808) (#xBFDD #x9162) (#xBFDE #x56F3) (#xBFDF #x53A8) (#xBFE0 #x9017) (#xBFE1 #x5439) (#xBFE2 #x5782) (#xBFE3 #x5E25) (#xBFE4 #x63A8) (#xBFE5 #x6C34) (#xBFE6 #x708A) (#xBFE7 #x7761) (#xBFE8 #x7C8B) (#xBFE9 #x7FE0) (#xBFEA #x8870) (#xBFEB #x9042) (#xBFEC #x9154) (#xBFED #x9310) (#xBFEE #x9318) (#xBFEF #x968F) (#xBFF0 #x745E) (#xBFF1 #x9AC4) (#xBFF2 #x5D07) (#xBFF3 #x5D69) (#xBFF4 #x6570) (#xBFF5 #x67A2) (#xBFF6 #x8DA8) (#xBFF7 #x96DB) (#xBFF8 #x636E) (#xBFF9 #x6749) (#xBFFA #x6919) (#xBFFB #x83C5) (#xBFFC #x9817) (#xBFFD #x96C0) (#xBFFE #x88FE) (#xC0A1 #x6F84) (#xC0A2 #x647A) (#xC0A3 #x5BF8) (#xC0A4 #x4E16) (#xC0A5 #x702C) (#xC0A6 #x755D) (#xC0A7 #x662F) (#xC0A8 #x51C4) (#xC0A9 #x5236) (#xC0AA #x52E2) (#xC0AB #x59D3) (#xC0AC #x5F81) (#xC0AD #x6027) (#xC0AE #x6210) (#xC0AF #x653F) (#xC0B0 #x6574) (#xC0B1 #x661F) (#xC0B2 #x6674) (#xC0B3 #x68F2) (#xC0B4 #x6816) (#xC0B5 #x6B63) (#xC0B6 #x6E05) (#xC0B7 #x7272) (#xC0B8 #x751F) (#xC0B9 #x76DB) (#xC0BA #x7CBE) (#xC0BB #x8056) (#xC0BC #x58F0) (#xC0BD #x88FD) (#xC0BE #x897F) (#xC0BF #x8AA0) (#xC0C0 #x8A93) (#xC0C1 #x8ACB) (#xC0C2 #x901D) (#xC0C3 #x9192) (#xC0C4 #x9752) (#xC0C5 #x9759) (#xC0C6 #x6589) (#xC0C7 #x7A0E) (#xC0C8 #x8106) (#xC0C9 #x96BB) (#xC0CA #x5E2D) (#xC0CB #x60DC) (#xC0CC #x621A) (#xC0CD #x65A5) (#xC0CE #x6614) (#xC0CF #x6790) (#xC0D0 #x77F3) (#xC0D1 #x7A4D) (#xC0D2 #x7C4D) (#xC0D3 #x7E3E) (#xC0D4 #x810A) (#xC0D5 #x8CAC) (#xC0D6 #x8D64) (#xC0D7 #x8DE1) (#xC0D8 #x8E5F) (#xC0D9 #x78A9) (#xC0DA #x5207) (#xC0DB #x62D9) (#xC0DC #x63A5) (#xC0DD #x6442) (#xC0DE #x6298) (#xC0DF #x8A2D) (#xC0E0 #x7A83) (#xC0E1 #x7BC0) (#xC0E2 #x8AAC) (#xC0E3 #x96EA) (#xC0E4 #x7D76) (#xC0E5 #x820C) (#xC0E6 #x8749) (#xC0E7 #x4ED9) (#xC0E8 #x5148) (#xC0E9 #x5343) (#xC0EA #x5360) (#xC0EB #x5BA3) (#xC0EC #x5C02) (#xC0ED #x5C16) (#xC0EE #x5DDD) (#xC0EF #x6226) (#xC0F0 #x6247) (#xC0F1 #x64B0) (#xC0F2 #x6813) (#xC0F3 #x6834) (#xC0F4 #x6CC9) (#xC0F5 #x6D45) (#xC0F6 #x6D17) (#xC0F7 #x67D3) (#xC0F8 #x6F5C) (#xC0F9 #x714E) (#xC0FA #x717D) (#xC0FB #x65CB) (#xC0FC #x7A7F) (#xC0FD #x7BAD) (#xC0FE #x7DDA) (#xC1A1 #x7E4A) (#xC1A2 #x7FA8) (#xC1A3 #x817A) (#xC1A4 #x821B) (#xC1A5 #x8239) (#xC1A6 #x85A6) (#xC1A7 #x8A6E) (#xC1A8 #x8CCE) (#xC1A9 #x8DF5) (#xC1AA #x9078) (#xC1AB #x9077) (#xC1AC #x92AD) (#xC1AD #x9291) (#xC1AE #x9583) (#xC1AF #x9BAE) (#xC1B0 #x524D) (#xC1B1 #x5584) (#xC1B2 #x6F38) (#xC1B3 #x7136) (#xC1B4 #x5168) (#xC1B5 #x7985) (#xC1B6 #x7E55) (#xC1B7 #x81B3) (#xC1B8 #x7CCE) (#xC1B9 #x564C) (#xC1BA #x5851) (#xC1BB #x5CA8) (#xC1BC #x63AA) (#xC1BD #x66FE) (#xC1BE #x66FD) (#xC1BF #x695A) (#xC1C0 #x72D9) (#xC1C1 #x758F) (#xC1C2 #x758E) (#xC1C3 #x790E) (#xC1C4 #x7956) (#xC1C5 #x79DF) (#xC1C6 #x7C97) (#xC1C7 #x7D20) (#xC1C8 #x7D44) (#xC1C9 #x8607) (#xC1CA #x8A34) (#xC1CB #x963B) (#xC1CC #x9061) (#xC1CD #x9F20) (#xC1CE #x50E7) (#xC1CF #x5275) (#xC1D0 #x53CC) (#xC1D1 #x53E2) (#xC1D2 #x5009) (#xC1D3 #x55AA) (#xC1D4 #x58EE) (#xC1D5 #x594F) (#xC1D6 #x723D) (#xC1D7 #x5B8B) (#xC1D8 #x5C64) (#xC1D9 #x531D) (#xC1DA #x60E3) (#xC1DB #x60F3) (#xC1DC #x635C) (#xC1DD #x6383) (#xC1DE #x633F) (#xC1DF #x63BB) (#xC1E0 #x64CD) (#xC1E1 #x65E9) (#xC1E2 #x66F9) (#xC1E3 #x5DE3) (#xC1E4 #x69CD) (#xC1E5 #x69FD) (#xC1E6 #x6F15) (#xC1E7 #x71E5) (#xC1E8 #x4E89) (#xC1E9 #x75E9) (#xC1EA #x76F8) (#xC1EB #x7A93) (#xC1EC #x7CDF) (#xC1ED #x7DCF) (#xC1EE #x7D9C) (#xC1EF #x8061) (#xC1F0 #x8349) (#xC1F1 #x8358) (#xC1F2 #x846C) (#xC1F3 #x84BC) (#xC1F4 #x85FB) (#xC1F5 #x88C5) (#xC1F6 #x8D70) (#xC1F7 #x9001) (#xC1F8 #x906D) (#xC1F9 #x9397) (#xC1FA #x971C) (#xC1FB #x9A12) (#xC1FC #x50CF) (#xC1FD #x5897) (#xC1FE #x618E) (#xC2A1 #x81D3) (#xC2A2 #x8535) (#xC2A3 #x8D08) (#xC2A4 #x9020) (#xC2A5 #x4FC3) (#xC2A6 #x5074) (#xC2A7 #x5247) (#xC2A8 #x5373) (#xC2A9 #x606F) (#xC2AA #x6349) (#xC2AB #x675F) (#xC2AC #x6E2C) (#xC2AD #x8DB3) (#xC2AE #x901F) (#xC2AF #x4FD7) (#xC2B0 #x5C5E) (#xC2B1 #x8CCA) (#xC2B2 #x65CF) (#xC2B3 #x7D9A) (#xC2B4 #x5352) (#xC2B5 #x8896) (#xC2B6 #x5176) (#xC2B7 #x63C3) (#xC2B8 #x5B58) (#xC2B9 #x5B6B) (#xC2BA #x5C0A) (#xC2BB #x640D) (#xC2BC #x6751) (#xC2BD #x905C) (#xC2BE #x4ED6) (#xC2BF #x591A) (#xC2C0 #x592A) (#xC2C1 #x6C70) (#xC2C2 #x8A51) (#xC2C3 #x553E) (#xC2C4 #x5815) (#xC2C5 #x59A5) (#xC2C6 #x60F0) (#xC2C7 #x6253) (#xC2C8 #x67C1) (#xC2C9 #x8235) (#xC2CA #x6955) (#xC2CB #x9640) (#xC2CC #x99C4) (#xC2CD #x9A28) (#xC2CE #x4F53) (#xC2CF #x5806) (#xC2D0 #x5BFE) (#xC2D1 #x8010) (#xC2D2 #x5CB1) (#xC2D3 #x5E2F) (#xC2D4 #x5F85) (#xC2D5 #x6020) (#xC2D6 #x614B) (#xC2D7 #x6234) (#xC2D8 #x66FF) (#xC2D9 #x6CF0) (#xC2DA #x6EDE) (#xC2DB #x80CE) (#xC2DC #x817F) (#xC2DD #x82D4) (#xC2DE #x888B) (#xC2DF #x8CB8) (#xC2E0 #x9000) (#xC2E1 #x902E) (#xC2E2 #x968A) (#xC2E3 #x9EDB) (#xC2E4 #x9BDB) (#xC2E5 #x4EE3) (#xC2E6 #x53F0) (#xC2E7 #x5927) (#xC2E8 #x7B2C) (#xC2E9 #x918D) (#xC2EA #x984C) (#xC2EB #x9DF9) (#xC2EC #x6EDD) (#xC2ED #x7027) (#xC2EE #x5353) (#xC2EF #x5544) (#xC2F0 #x5B85) (#xC2F1 #x6258) (#xC2F2 #x629E) (#xC2F3 #x62D3) (#xC2F4 #x6CA2) (#xC2F5 #x6FEF) (#xC2F6 #x7422) (#xC2F7 #x8A17) (#xC2F8 #x9438) (#xC2F9 #x6FC1) (#xC2FA #x8AFE) (#xC2FB #x8338) (#xC2FC #x51E7) (#xC2FD #x86F8) (#xC2FE #x53EA) (#xC3A1 #x53E9) (#xC3A2 #x4F46) (#xC3A3 #x9054) (#xC3A4 #x8FB0) (#xC3A5 #x596A) (#xC3A6 #x8131) (#xC3A7 #x5DFD) (#xC3A8 #x7AEA) (#xC3A9 #x8FBF) (#xC3AA #x68DA) (#xC3AB #x8C37) (#xC3AC #x72F8) (#xC3AD #x9C48) (#xC3AE #x6A3D) (#xC3AF #x8AB0) (#xC3B0 #x4E39) (#xC3B1 #x5358) (#xC3B2 #x5606) (#xC3B3 #x5766) (#xC3B4 #x62C5) (#xC3B5 #x63A2) (#xC3B6 #x65E6) (#xC3B7 #x6B4E) (#xC3B8 #x6DE1) (#xC3B9 #x6E5B) (#xC3BA #x70AD) (#xC3BB #x77ED) (#xC3BC #x7AEF) (#xC3BD #x7BAA) (#xC3BE #x7DBB) (#xC3BF #x803D) (#xC3C0 #x80C6) (#xC3C1 #x86CB) (#xC3C2 #x8A95) (#xC3C3 #x935B) (#xC3C4 #x56E3) (#xC3C5 #x58C7) (#xC3C6 #x5F3E) (#xC3C7 #x65AD) (#xC3C8 #x6696) (#xC3C9 #x6A80) (#xC3CA #x6BB5) (#xC3CB #x7537) (#xC3CC #x8AC7) (#xC3CD #x5024) (#xC3CE #x77E5) (#xC3CF #x5730) (#xC3D0 #x5F1B) (#xC3D1 #x6065) (#xC3D2 #x667A) (#xC3D3 #x6C60) (#xC3D4 #x75F4) (#xC3D5 #x7A1A) (#xC3D6 #x7F6E) (#xC3D7 #x81F4) (#xC3D8 #x8718) (#xC3D9 #x9045) (#xC3DA #x99B3) (#xC3DB #x7BC9) (#xC3DC #x755C) (#xC3DD #x7AF9) (#xC3DE #x7B51) (#xC3DF #x84C4) (#xC3E0 #x9010) (#xC3E1 #x79E9) (#xC3E2 #x7A92) (#xC3E3 #x8336) (#xC3E4 #x5AE1) (#xC3E5 #x7740) (#xC3E6 #x4E2D) (#xC3E7 #x4EF2) (#xC3E8 #x5B99) (#xC3E9 #x5FE0) (#xC3EA #x62BD) (#xC3EB #x663C) (#xC3EC #x67F1) (#xC3ED #x6CE8) (#xC3EE #x866B) (#xC3EF #x8877) (#xC3F0 #x8A3B) (#xC3F1 #x914E) (#xC3F2 #x92F3) (#xC3F3 #x99D0) (#xC3F4 #x6A17) (#xC3F5 #x7026) (#xC3F6 #x732A) (#xC3F7 #x82E7) (#xC3F8 #x8457) (#xC3F9 #x8CAF) (#xC3FA #x4E01) (#xC3FB #x5146) (#xC3FC #x51CB) (#xC3FD #x558B) (#xC3FE #x5BF5) (#xC4A1 #x5E16) (#xC4A2 #x5E33) (#xC4A3 #x5E81) (#xC4A4 #x5F14) (#xC4A5 #x5F35) (#xC4A6 #x5F6B) (#xC4A7 #x5FB4) (#xC4A8 #x61F2) (#xC4A9 #x6311) (#xC4AA #x66A2) (#xC4AB #x671D) (#xC4AC #x6F6E) (#xC4AD #x7252) (#xC4AE #x753A) (#xC4AF #x773A) (#xC4B0 #x8074) (#xC4B1 #x8139) (#xC4B2 #x8178) (#xC4B3 #x8776) (#xC4B4 #x8ABF) (#xC4B5 #x8ADC) (#xC4B6 #x8D85) (#xC4B7 #x8DF3) (#xC4B8 #x929A) (#xC4B9 #x9577) (#xC4BA #x9802) (#xC4BB #x9CE5) (#xC4BC #x52C5) (#xC4BD #x6357) (#xC4BE #x76F4) (#xC4BF #x6715) (#xC4C0 #x6C88) (#xC4C1 #x73CD) (#xC4C2 #x8CC3) (#xC4C3 #x93AE) (#xC4C4 #x9673) (#xC4C5 #x6D25) (#xC4C6 #x589C) (#xC4C7 #x690E) (#xC4C8 #x69CC) (#xC4C9 #x8FFD) (#xC4CA #x939A) (#xC4CB #x75DB) (#xC4CC #x901A) (#xC4CD #x585A) (#xC4CE #x6802) (#xC4CF #x63B4) (#xC4D0 #x69FB) (#xC4D1 #x4F43) (#xC4D2 #x6F2C) (#xC4D3 #x67D8) (#xC4D4 #x8FBB) (#xC4D5 #x8526) (#xC4D6 #x7DB4) (#xC4D7 #x9354) (#xC4D8 #x693F) (#xC4D9 #x6F70) (#xC4DA #x576A) (#xC4DB #x58F7) (#xC4DC #x5B2C) (#xC4DD #x7D2C) (#xC4DE #x722A) (#xC4DF #x540A) (#xC4E0 #x91E3) (#xC4E1 #x9DB4) (#xC4E2 #x4EAD) (#xC4E3 #x4F4E) (#xC4E4 #x505C) (#xC4E5 #x5075) (#xC4E6 #x5243) (#xC4E7 #x8C9E) (#xC4E8 #x5448) (#xC4E9 #x5824) (#xC4EA #x5B9A) (#xC4EB #x5E1D) (#xC4EC #x5E95) (#xC4ED #x5EAD) (#xC4EE #x5EF7) (#xC4EF #x5F1F) (#xC4F0 #x608C) (#xC4F1 #x62B5) (#xC4F2 #x633A) (#xC4F3 #x63D0) (#xC4F4 #x68AF) (#xC4F5 #x6C40) (#xC4F6 #x7887) (#xC4F7 #x798E) (#xC4F8 #x7A0B) (#xC4F9 #x7DE0) (#xC4FA #x8247) (#xC4FB #x8A02) (#xC4FC #x8AE6) (#xC4FD #x8E44) (#xC4FE #x9013) (#xC5A1 #x90B8) (#xC5A2 #x912D) (#xC5A3 #x91D8) (#xC5A4 #x9F0E) (#xC5A5 #x6CE5) (#xC5A6 #x6458) (#xC5A7 #x64E2) (#xC5A8 #x6575) (#xC5A9 #x6EF4) (#xC5AA #x7684) (#xC5AB #x7B1B) (#xC5AC #x9069) (#xC5AD #x93D1) (#xC5AE #x6EBA) (#xC5AF #x54F2) (#xC5B0 #x5FB9) (#xC5B1 #x64A4) (#xC5B2 #x8F4D) (#xC5B3 #x8FED) (#xC5B4 #x9244) (#xC5B5 #x5178) (#xC5B6 #x586B) (#xC5B7 #x5929) (#xC5B8 #x5C55) (#xC5B9 #x5E97) (#xC5BA #x6DFB) (#xC5BB #x7E8F) (#xC5BC #x751C) (#xC5BD #x8CBC) (#xC5BE #x8EE2) (#xC5BF #x985B) (#xC5C0 #x70B9) (#xC5C1 #x4F1D) (#xC5C2 #x6BBF) (#xC5C3 #x6FB1) (#xC5C4 #x7530) (#xC5C5 #x96FB) (#xC5C6 #x514E) (#xC5C7 #x5410) (#xC5C8 #x5835) (#xC5C9 #x5857) (#xC5CA #x59AC) (#xC5CB #x5C60) (#xC5CC #x5F92) (#xC5CD #x6597) (#xC5CE #x675C) (#xC5CF #x6E21) (#xC5D0 #x767B) (#xC5D1 #x83DF) (#xC5D2 #x8CED) (#xC5D3 #x9014) (#xC5D4 #x90FD) (#xC5D5 #x934D) (#xC5D6 #x7825) (#xC5D7 #x783A) (#xC5D8 #x52AA) (#xC5D9 #x5EA6) (#xC5DA #x571F) (#xC5DB #x5974) (#xC5DC #x6012) (#xC5DD #x5012) (#xC5DE #x515A) (#xC5DF #x51AC) (#xC5E0 #x51CD) (#xC5E1 #x5200) (#xC5E2 #x5510) (#xC5E3 #x5854) (#xC5E4 #x5858) (#xC5E5 #x5957) (#xC5E6 #x5B95) (#xC5E7 #x5CF6) (#xC5E8 #x5D8B) (#xC5E9 #x60BC) (#xC5EA #x6295) (#xC5EB #x642D) (#xC5EC #x6771) (#xC5ED #x6843) (#xC5EE #x68BC) (#xC5EF #x68DF) (#xC5F0 #x76D7) (#xC5F1 #x6DD8) (#xC5F2 #x6E6F) (#xC5F3 #x6D9B) (#xC5F4 #x706F) (#xC5F5 #x71C8) (#xC5F6 #x5F53) (#xC5F7 #x75D8) (#xC5F8 #x7977) (#xC5F9 #x7B49) (#xC5FA #x7B54) (#xC5FB #x7B52) (#xC5FC #x7CD6) (#xC5FD #x7D71) (#xC5FE #x5230) (#xC6A1 #x8463) (#xC6A2 #x8569) (#xC6A3 #x85E4) (#xC6A4 #x8A0E) (#xC6A5 #x8B04) (#xC6A6 #x8C46) (#xC6A7 #x8E0F) (#xC6A8 #x9003) (#xC6A9 #x900F) (#xC6AA #x9419) (#xC6AB #x9676) (#xC6AC #x982D) (#xC6AD #x9A30) (#xC6AE #x95D8) (#xC6AF #x50CD) (#xC6B0 #x52D5) (#xC6B1 #x540C) (#xC6B2 #x5802) (#xC6B3 #x5C0E) (#xC6B4 #x61A7) (#xC6B5 #x649E) (#xC6B6 #x6D1E) (#xC6B7 #x77B3) (#xC6B8 #x7AE5) (#xC6B9 #x80F4) (#xC6BA #x8404) (#xC6BB #x9053) (#xC6BC #x9285) (#xC6BD #x5CE0) (#xC6BE #x9D07) (#xC6BF #x533F) (#xC6C0 #x5F97) (#xC6C1 #x5FB3) (#xC6C2 #x6D9C) (#xC6C3 #x7279) (#xC6C4 #x7763) (#xC6C5 #x79BF) (#xC6C6 #x7BE4) (#xC6C7 #x6BD2) (#xC6C8 #x72EC) (#xC6C9 #x8AAD) (#xC6CA #x6803) (#xC6CB #x6A61) (#xC6CC #x51F8) (#xC6CD #x7A81) (#xC6CE #x6934) (#xC6CF #x5C4A) (#xC6D0 #x9CF6) (#xC6D1 #x82EB) (#xC6D2 #x5BC5) (#xC6D3 #x9149) (#xC6D4 #x701E) (#xC6D5 #x5678) (#xC6D6 #x5C6F) (#xC6D7 #x60C7) (#xC6D8 #x6566) (#xC6D9 #x6C8C) (#xC6DA #x8C5A) (#xC6DB #x9041) (#xC6DC #x9813) (#xC6DD #x5451) (#xC6DE #x66C7) (#xC6DF #x920D) (#xC6E0 #x5948) (#xC6E1 #x90A3) (#xC6E2 #x5185) (#xC6E3 #x4E4D) (#xC6E4 #x51EA) (#xC6E5 #x8599) (#xC6E6 #x8B0E) (#xC6E7 #x7058) (#xC6E8 #x637A) (#xC6E9 #x934B) (#xC6EA #x6962) (#xC6EB #x99B4) (#xC6EC #x7E04) (#xC6ED #x7577) (#xC6EE #x5357) (#xC6EF #x6960) (#xC6F0 #x8EDF) (#xC6F1 #x96E3) (#xC6F2 #x6C5D) (#xC6F3 #x4E8C) (#xC6F4 #x5C3C) (#xC6F5 #x5F10) (#xC6F6 #x8FE9) (#xC6F7 #x5302) (#xC6F8 #x8CD1) (#xC6F9 #x8089) (#xC6FA #x8679) (#xC6FB #x5EFF) (#xC6FC #x65E5) (#xC6FD #x4E73) (#xC6FE #x5165) (#xC7A1 #x5982) (#xC7A2 #x5C3F) (#xC7A3 #x97EE) (#xC7A4 #x4EFB) (#xC7A5 #x598A) (#xC7A6 #x5FCD) (#xC7A7 #x8A8D) (#xC7A8 #x6FE1) (#xC7A9 #x79B0) (#xC7AA #x7962) (#xC7AB #x5BE7) (#xC7AC #x8471) (#xC7AD #x732B) (#xC7AE #x71B1) (#xC7AF #x5E74) (#xC7B0 #x5FF5) (#xC7B1 #x637B) (#xC7B2 #x649A) (#xC7B3 #x71C3) (#xC7B4 #x7C98) (#xC7B5 #x4E43) (#xC7B6 #x5EFC) (#xC7B7 #x4E4B) (#xC7B8 #x57DC) (#xC7B9 #x56A2) (#xC7BA #x60A9) (#xC7BB #x6FC3) (#xC7BC #x7D0D) (#xC7BD #x80FD) (#xC7BE #x8133) (#xC7BF #x81BF) (#xC7C0 #x8FB2) (#xC7C1 #x8997) (#xC7C2 #x86A4) (#xC7C3 #x5DF4) (#xC7C4 #x628A) (#xC7C5 #x64AD) (#xC7C6 #x8987) (#xC7C7 #x6777) (#xC7C8 #x6CE2) (#xC7C9 #x6D3E) (#xC7CA #x7436) (#xC7CB #x7834) (#xC7CC #x5A46) (#xC7CD #x7F75) (#xC7CE #x82AD) (#xC7CF #x99AC) (#xC7D0 #x4FF3) (#xC7D1 #x5EC3) (#xC7D2 #x62DD) (#xC7D3 #x6392) (#xC7D4 #x6557) (#xC7D5 #x676F) (#xC7D6 #x76C3) (#xC7D7 #x724C) (#xC7D8 #x80CC) (#xC7D9 #x80BA) (#xC7DA #x8F29) (#xC7DB #x914D) (#xC7DC #x500D) (#xC7DD #x57F9) (#xC7DE #x5A92) (#xC7DF #x6885) (#xC7E0 #x6973) (#xC7E1 #x7164) (#xC7E2 #x72FD) (#xC7E3 #x8CB7) (#xC7E4 #x58F2) (#xC7E5 #x8CE0) (#xC7E6 #x966A) (#xC7E7 #x9019) (#xC7E8 #x877F) (#xC7E9 #x79E4) (#xC7EA #x77E7) (#xC7EB #x8429) (#xC7EC #x4F2F) (#xC7ED #x5265) (#xC7EE #x535A) (#xC7EF #x62CD) (#xC7F0 #x67CF) (#xC7F1 #x6CCA) (#xC7F2 #x767D) (#xC7F3 #x7B94) (#xC7F4 #x7C95) (#xC7F5 #x8236) (#xC7F6 #x8584) (#xC7F7 #x8FEB) (#xC7F8 #x66DD) (#xC7F9 #x6F20) (#xC7FA #x7206) (#xC7FB #x7E1B) (#xC7FC #x83AB) (#xC7FD #x99C1) (#xC7FE #x9EA6) (#xC8A1 #x51FD) (#xC8A2 #x7BB1) (#xC8A3 #x7872) (#xC8A4 #x7BB8) (#xC8A5 #x8087) (#xC8A6 #x7B48) (#xC8A7 #x6AE8) (#xC8A8 #x5E61) (#xC8A9 #x808C) (#xC8AA #x7551) (#xC8AB #x7560) (#xC8AC #x516B) (#xC8AD #x9262) (#xC8AE #x6E8C) (#xC8AF #x767A) (#xC8B0 #x9197) (#xC8B1 #x9AEA) (#xC8B2 #x4F10) (#xC8B3 #x7F70) (#xC8B4 #x629C) (#xC8B5 #x7B4F) (#xC8B6 #x95A5) (#xC8B7 #x9CE9) (#xC8B8 #x567A) (#xC8B9 #x5859) (#xC8BA #x86E4) (#xC8BB #x96BC) (#xC8BC #x4F34) (#xC8BD #x5224) (#xC8BE #x534A) (#xC8BF #x53CD) (#xC8C0 #x53DB) (#xC8C1 #x5E06) (#xC8C2 #x642C) (#xC8C3 #x6591) (#xC8C4 #x677F) (#xC8C5 #x6C3E) (#xC8C6 #x6C4E) (#xC8C7 #x7248) (#xC8C8 #x72AF) (#xC8C9 #x73ED) (#xC8CA #x7554) (#xC8CB #x7E41) (#xC8CC #x822C) (#xC8CD #x85E9) (#xC8CE #x8CA9) (#xC8CF #x7BC4) (#xC8D0 #x91C6) (#xC8D1 #x7169) (#xC8D2 #x9812) (#xC8D3 #x98EF) (#xC8D4 #x633D) (#xC8D5 #x6669) (#xC8D6 #x756A) (#xC8D7 #x76E4) (#xC8D8 #x78D0) (#xC8D9 #x8543) (#xC8DA #x86EE) (#xC8DB #x532A) (#xC8DC #x5351) (#xC8DD #x5426) (#xC8DE #x5983) (#xC8DF #x5E87) (#xC8E0 #x5F7C) (#xC8E1 #x60B2) (#xC8E2 #x6249) (#xC8E3 #x6279) (#xC8E4 #x62AB) (#xC8E5 #x6590) (#xC8E6 #x6BD4) (#xC8E7 #x6CCC) (#xC8E8 #x75B2) (#xC8E9 #x76AE) (#xC8EA #x7891) (#xC8EB #x79D8) (#xC8EC #x7DCB) (#xC8ED #x7F77) (#xC8EE #x80A5) (#xC8EF #x88AB) (#xC8F0 #x8AB9) (#xC8F1 #x8CBB) (#xC8F2 #x907F) (#xC8F3 #x975E) (#xC8F4 #x98DB) (#xC8F5 #x6A0B) (#xC8F6 #x7C38) (#xC8F7 #x5099) (#xC8F8 #x5C3E) (#xC8F9 #x5FAE) (#xC8FA #x6787) (#xC8FB #x6BD8) (#xC8FC #x7435) (#xC8FD #x7709) (#xC8FE #x7F8E) (#xC9A1 #x9F3B) (#xC9A2 #x67CA) (#xC9A3 #x7A17) (#xC9A4 #x5339) (#xC9A5 #x758B) (#xC9A6 #x9AED) (#xC9A7 #x5F66) (#xC9A8 #x819D) (#xC9A9 #x83F1) (#xC9AA #x8098) (#xC9AB #x5F3C) (#xC9AC #x5FC5) (#xC9AD #x7562) (#xC9AE #x7B46) (#xC9AF #x903C) (#xC9B0 #x6867) (#xC9B1 #x59EB) (#xC9B2 #x5A9B) (#xC9B3 #x7D10) (#xC9B4 #x767E) (#xC9B5 #x8B2C) (#xC9B6 #x4FF5) (#xC9B7 #x5F6A) (#xC9B8 #x6A19) (#xC9B9 #x6C37) (#xC9BA #x6F02) (#xC9BB #x74E2) (#xC9BC #x7968) (#xC9BD #x8868) (#xC9BE #x8A55) (#xC9BF #x8C79) (#xC9C0 #x5EDF) (#xC9C1 #x63CF) (#xC9C2 #x75C5) (#xC9C3 #x79D2) (#xC9C4 #x82D7) (#xC9C5 #x9328) (#xC9C6 #x92F2) (#xC9C7 #x849C) (#xC9C8 #x86ED) (#xC9C9 #x9C2D) (#xC9CA #x54C1) (#xC9CB #x5F6C) (#xC9CC #x658C) (#xC9CD #x6D5C) (#xC9CE #x7015) (#xC9CF #x8CA7) (#xC9D0 #x8CD3) (#xC9D1 #x983B) (#xC9D2 #x654F) (#xC9D3 #x74F6) (#xC9D4 #x4E0D) (#xC9D5 #x4ED8) (#xC9D6 #x57E0) (#xC9D7 #x592B) (#xC9D8 #x5A66) (#xC9D9 #x5BCC) (#xC9DA #x51A8) (#xC9DB #x5E03) (#xC9DC #x5E9C) (#xC9DD #x6016) (#xC9DE #x6276) (#xC9DF #x6577) (#xC9E0 #x65A7) (#xC9E1 #x666E) (#xC9E2 #x6D6E) (#xC9E3 #x7236) (#xC9E4 #x7B26) (#xC9E5 #x8150) (#xC9E6 #x819A) (#xC9E7 #x8299) (#xC9E8 #x8B5C) (#xC9E9 #x8CA0) (#xC9EA #x8CE6) (#xC9EB #x8D74) (#xC9EC #x961C) (#xC9ED #x9644) (#xC9EE #x4FAE) (#xC9EF #x64AB) (#xC9F0 #x6B66) (#xC9F1 #x821E) (#xC9F2 #x8461) (#xC9F3 #x856A) (#xC9F4 #x90E8) (#xC9F5 #x5C01) (#xC9F6 #x6953) (#xC9F7 #x98A8) (#xC9F8 #x847A) (#xC9F9 #x8557) (#xC9FA #x4F0F) (#xC9FB #x526F) (#xC9FC #x5FA9) (#xC9FD #x5E45) (#xC9FE #x670D) (#xCAA1 #x798F) (#xCAA2 #x8179) (#xCAA3 #x8907) (#xCAA4 #x8986) (#xCAA5 #x6DF5) (#xCAA6 #x5F17) (#xCAA7 #x6255) (#xCAA8 #x6CB8) (#xCAA9 #x4ECF) (#xCAAA #x7269) (#xCAAB #x9B92) (#xCAAC #x5206) (#xCAAD #x543B) (#xCAAE #x5674) (#xCAAF #x58B3) (#xCAB0 #x61A4) (#xCAB1 #x626E) (#xCAB2 #x711A) (#xCAB3 #x596E) (#xCAB4 #x7C89) (#xCAB5 #x7CDE) (#xCAB6 #x7D1B) (#xCAB7 #x96F0) (#xCAB8 #x6587) (#xCAB9 #x805E) (#xCABA #x4E19) (#xCABB #x4F75) (#xCABC #x5175) (#xCABD #x5840) (#xCABE #x5E63) (#xCABF #x5E73) (#xCAC0 #x5F0A) (#xCAC1 #x67C4) (#xCAC2 #x4E26) (#xCAC3 #x853D) (#xCAC4 #x9589) (#xCAC5 #x965B) (#xCAC6 #x7C73) (#xCAC7 #x9801) (#xCAC8 #x50FB) (#xCAC9 #x58C1) (#xCACA #x7656) (#xCACB #x78A7) (#xCACC #x5225) (#xCACD #x77A5) (#xCACE #x8511) (#xCACF #x7B86) (#xCAD0 #x504F) (#xCAD1 #x5909) (#xCAD2 #x7247) (#xCAD3 #x7BC7) (#xCAD4 #x7DE8) (#xCAD5 #x8FBA) (#xCAD6 #x8FD4) (#xCAD7 #x904D) (#xCAD8 #x4FBF) (#xCAD9 #x52C9) (#xCADA #x5A29) (#xCADB #x5F01) (#xCADC #x97AD) (#xCADD #x4FDD) (#xCADE #x8217) (#xCADF #x92EA) (#xCAE0 #x5703) (#xCAE1 #x6355) (#xCAE2 #x6B69) (#xCAE3 #x752B) (#xCAE4 #x88DC) (#xCAE5 #x8F14) (#xCAE6 #x7A42) (#xCAE7 #x52DF) (#xCAE8 #x5893) (#xCAE9 #x6155) (#xCAEA #x620A) (#xCAEB #x66AE) (#xCAEC #x6BCD) (#xCAED #x7C3F) (#xCAEE #x83E9) (#xCAEF #x5023) (#xCAF0 #x4FF8) (#xCAF1 #x5305) (#xCAF2 #x5446) (#xCAF3 #x5831) (#xCAF4 #x5949) (#xCAF5 #x5B9D) (#xCAF6 #x5CF0) (#xCAF7 #x5CEF) (#xCAF8 #x5D29) (#xCAF9 #x5E96) (#xCAFA #x62B1) (#xCAFB #x6367) (#xCAFC #x653E) (#xCAFD #x65B9) (#xCAFE #x670B) (#xCBA1 #x6CD5) (#xCBA2 #x6CE1) (#xCBA3 #x70F9) (#xCBA4 #x7832) (#xCBA5 #x7E2B) (#xCBA6 #x80DE) (#xCBA7 #x82B3) (#xCBA8 #x840C) (#xCBA9 #x84EC) (#xCBAA #x8702) (#xCBAB #x8912) (#xCBAC #x8A2A) (#xCBAD #x8C4A) (#xCBAE #x90A6) (#xCBAF #x92D2) (#xCBB0 #x98FD) (#xCBB1 #x9CF3) (#xCBB2 #x9D6C) (#xCBB3 #x4E4F) (#xCBB4 #x4EA1) (#xCBB5 #x508D) (#xCBB6 #x5256) (#xCBB7 #x574A) (#xCBB8 #x59A8) (#xCBB9 #x5E3D) (#xCBBA #x5FD8) (#xCBBB #x5FD9) (#xCBBC #x623F) (#xCBBD #x66B4) (#xCBBE #x671B) (#xCBBF #x67D0) (#xCBC0 #x68D2) (#xCBC1 #x5192) (#xCBC2 #x7D21) (#xCBC3 #x80AA) (#xCBC4 #x81A8) (#xCBC5 #x8B00) (#xCBC6 #x8C8C) (#xCBC7 #x8CBF) (#xCBC8 #x927E) (#xCBC9 #x9632) (#xCBCA #x5420) (#xCBCB #x982C) (#xCBCC #x5317) (#xCBCD #x50D5) (#xCBCE #x535C) (#xCBCF #x58A8) (#xCBD0 #x64B2) (#xCBD1 #x6734) (#xCBD2 #x7267) (#xCBD3 #x7766) (#xCBD4 #x7A46) (#xCBD5 #x91E6) (#xCBD6 #x52C3) (#xCBD7 #x6CA1) (#xCBD8 #x6B86) (#xCBD9 #x5800) (#xCBDA #x5E4C) (#xCBDB #x5954) (#xCBDC #x672C) (#xCBDD #x7FFB) (#xCBDE #x51E1) (#xCBDF #x76C6) (#xCBE0 #x6469) (#xCBE1 #x78E8) (#xCBE2 #x9B54) (#xCBE3 #x9EBB) (#xCBE4 #x57CB) (#xCBE5 #x59B9) (#xCBE6 #x6627) (#xCBE7 #x679A) (#xCBE8 #x6BCE) (#xCBE9 #x54E9) (#xCBEA #x69D9) (#xCBEB #x5E55) (#xCBEC #x819C) (#xCBED #x6795) (#xCBEE #x9BAA) (#xCBEF #x67FE) (#xCBF0 #x9C52) (#xCBF1 #x685D) (#xCBF2 #x4EA6) (#xCBF3 #x4FE3) (#xCBF4 #x53C8) (#xCBF5 #x62B9) (#xCBF6 #x672B) (#xCBF7 #x6CAB) (#xCBF8 #x8FC4) (#xCBF9 #x4FAD) (#xCBFA #x7E6D) (#xCBFB #x9EBF) (#xCBFC #x4E07) (#xCBFD #x6162) (#xCBFE #x6E80) (#xCCA1 #x6F2B) (#xCCA2 #x8513) (#xCCA3 #x5473) (#xCCA4 #x672A) (#xCCA5 #x9B45) (#xCCA6 #x5DF3) (#xCCA7 #x7B95) (#xCCA8 #x5CAC) (#xCCA9 #x5BC6) (#xCCAA #x871C) (#xCCAB #x6E4A) (#xCCAC #x84D1) (#xCCAD #x7A14) (#xCCAE #x8108) (#xCCAF #x5999) (#xCCB0 #x7C8D) (#xCCB1 #x6C11) (#xCCB2 #x7720) (#xCCB3 #x52D9) (#xCCB4 #x5922) (#xCCB5 #x7121) (#xCCB6 #x725F) (#xCCB7 #x77DB) (#xCCB8 #x9727) (#xCCB9 #x9D61) (#xCCBA #x690B) (#xCCBB #x5A7F) (#xCCBC #x5A18) (#xCCBD #x51A5) (#xCCBE #x540D) (#xCCBF #x547D) (#xCCC0 #x660E) (#xCCC1 #x76DF) (#xCCC2 #x8FF7) (#xCCC3 #x9298) (#xCCC4 #x9CF4) (#xCCC5 #x59EA) (#xCCC6 #x725D) (#xCCC7 #x6EC5) (#xCCC8 #x514D) (#xCCC9 #x68C9) (#xCCCA #x7DBF) (#xCCCB #x7DEC) (#xCCCC #x9762) (#xCCCD #x9EBA) (#xCCCE #x6478) (#xCCCF #x6A21) (#xCCD0 #x8302) (#xCCD1 #x5984) (#xCCD2 #x5B5F) (#xCCD3 #x6BDB) (#xCCD4 #x731B) (#xCCD5 #x76F2) (#xCCD6 #x7DB2) (#xCCD7 #x8017) (#xCCD8 #x8499) (#xCCD9 #x5132) (#xCCDA #x6728) (#xCCDB #x9ED9) (#xCCDC #x76EE) (#xCCDD #x6762) (#xCCDE #x52FF) (#xCCDF #x9905) (#xCCE0 #x5C24) (#xCCE1 #x623B) (#xCCE2 #x7C7E) (#xCCE3 #x8CB0) (#xCCE4 #x554F) (#xCCE5 #x60B6) (#xCCE6 #x7D0B) (#xCCE7 #x9580) (#xCCE8 #x5301) (#xCCE9 #x4E5F) (#xCCEA #x51B6) (#xCCEB #x591C) (#xCCEC #x723A) (#xCCED #x8036) (#xCCEE #x91CE) (#xCCEF #x5F25) (#xCCF0 #x77E2) (#xCCF1 #x5384) (#xCCF2 #x5F79) (#xCCF3 #x7D04) (#xCCF4 #x85AC) (#xCCF5 #x8A33) (#xCCF6 #x8E8D) (#xCCF7 #x9756) (#xCCF8 #x67F3) (#xCCF9 #x85AE) (#xCCFA #x9453) (#xCCFB #x6109) (#xCCFC #x6108) (#xCCFD #x6CB9) (#xCCFE #x7652) (#xCDA1 #x8AED) (#xCDA2 #x8F38) (#xCDA3 #x552F) (#xCDA4 #x4F51) (#xCDA5 #x512A) (#xCDA6 #x52C7) (#xCDA7 #x53CB) (#xCDA8 #x5BA5) (#xCDA9 #x5E7D) (#xCDAA #x60A0) (#xCDAB #x6182) (#xCDAC #x63D6) (#xCDAD #x6709) (#xCDAE #x67DA) (#xCDAF #x6E67) (#xCDB0 #x6D8C) (#xCDB1 #x7336) (#xCDB2 #x7337) (#xCDB3 #x7531) (#xCDB4 #x7950) (#xCDB5 #x88D5) (#xCDB6 #x8A98) (#xCDB7 #x904A) (#xCDB8 #x9091) (#xCDB9 #x90F5) (#xCDBA #x96C4) (#xCDBB #x878D) (#xCDBC #x5915) (#xCDBD #x4E88) (#xCDBE #x4F59) (#xCDBF #x4E0E) (#xCDC0 #x8A89) (#xCDC1 #x8F3F) (#xCDC2 #x9810) (#xCDC3 #x50AD) (#xCDC4 #x5E7C) (#xCDC5 #x5996) (#xCDC6 #x5BB9) (#xCDC7 #x5EB8) (#xCDC8 #x63DA) (#xCDC9 #x63FA) (#xCDCA #x64C1) (#xCDCB #x66DC) (#xCDCC #x694A) (#xCDCD #x69D8) (#xCDCE #x6D0B) (#xCDCF #x6EB6) (#xCDD0 #x7194) (#xCDD1 #x7528) (#xCDD2 #x7AAF) (#xCDD3 #x7F8A) (#xCDD4 #x8000) (#xCDD5 #x8449) (#xCDD6 #x84C9) (#xCDD7 #x8981) (#xCDD8 #x8B21) (#xCDD9 #x8E0A) (#xCDDA #x9065) (#xCDDB #x967D) (#xCDDC #x990A) (#xCDDD #x617E) (#xCDDE #x6291) (#xCDDF #x6B32) (#xCDE0 #x6C83) (#xCDE1 #x6D74) (#xCDE2 #x7FCC) (#xCDE3 #x7FFC) (#xCDE4 #x6DC0) (#xCDE5 #x7F85) (#xCDE6 #x87BA) (#xCDE7 #x88F8) (#xCDE8 #x6765) (#xCDE9 #x83B1) (#xCDEA #x983C) (#xCDEB #x96F7) (#xCDEC #x6D1B) (#xCDED #x7D61) (#xCDEE #x843D) (#xCDEF #x916A) (#xCDF0 #x4E71) (#xCDF1 #x5375) (#xCDF2 #x5D50) (#xCDF3 #x6B04) (#xCDF4 #x6FEB) (#xCDF5 #x85CD) (#xCDF6 #x862D) (#xCDF7 #x89A7) (#xCDF8 #x5229) (#xCDF9 #x540F) (#xCDFA #x5C65) (#xCDFB #x674E) (#xCDFC #x68A8) (#xCDFD #x7406) (#xCDFE #x7483) (#xCEA1 #x75E2) (#xCEA2 #x88CF) (#xCEA3 #x88E1) (#xCEA4 #x91CC) (#xCEA5 #x96E2) (#xCEA6 #x9678) (#xCEA7 #x5F8B) (#xCEA8 #x7387) (#xCEA9 #x7ACB) (#xCEAA #x844E) (#xCEAB #x63A0) (#xCEAC #x7565) (#xCEAD #x5289) (#xCEAE #x6D41) (#xCEAF #x6E9C) (#xCEB0 #x7409) (#xCEB1 #x7559) (#xCEB2 #x786B) (#xCEB3 #x7C92) (#xCEB4 #x9686) (#xCEB5 #x7ADC) (#xCEB6 #x9F8D) (#xCEB7 #x4FB6) (#xCEB8 #x616E) (#xCEB9 #x65C5) (#xCEBA #x865C) (#xCEBB #x4E86) (#xCEBC #x4EAE) (#xCEBD #x50DA) (#xCEBE #x4E21) (#xCEBF #x51CC) (#xCEC0 #x5BEE) (#xCEC1 #x6599) (#xCEC2 #x6881) (#xCEC3 #x6DBC) (#xCEC4 #x731F) (#xCEC5 #x7642) (#xCEC6 #x77AD) (#xCEC7 #x7A1C) (#xCEC8 #x7CE7) (#xCEC9 #x826F) (#xCECA #x8AD2) (#xCECB #x907C) (#xCECC #x91CF) (#xCECD #x9675) (#xCECE #x9818) (#xCECF #x529B) (#xCED0 #x7DD1) (#xCED1 #x502B) (#xCED2 #x5398) (#xCED3 #x6797) (#xCED4 #x6DCB) (#xCED5 #x71D0) (#xCED6 #x7433) (#xCED7 #x81E8) (#xCED8 #x8F2A) (#xCED9 #x96A3) (#xCEDA #x9C57) (#xCEDB #x9E9F) (#xCEDC #x7460) (#xCEDD #x5841) (#xCEDE #x6D99) (#xCEDF #x7D2F) (#xCEE0 #x985E) (#xCEE1 #x4EE4) (#xCEE2 #x4F36) (#xCEE3 #x4F8B) (#xCEE4 #x51B7) (#xCEE5 #x52B1) (#xCEE6 #x5DBA) (#xCEE7 #x601C) (#xCEE8 #x73B2) (#xCEE9 #x793C) (#xCEEA #x82D3) (#xCEEB #x9234) (#xCEEC #x96B7) (#xCEED #x96F6) (#xCEEE #x970A) (#xCEEF #x9E97) (#xCEF0 #x9F62) (#xCEF1 #x66A6) (#xCEF2 #x6B74) (#xCEF3 #x5217) (#xCEF4 #x52A3) (#xCEF5 #x70C8) (#xCEF6 #x88C2) (#xCEF7 #x5EC9) (#xCEF8 #x604B) (#xCEF9 #x6190) (#xCEFA #x6F23) (#xCEFB #x7149) (#xCEFC #x7C3E) (#xCEFD #x7DF4) (#xCEFE #x806F) (#xCFA1 #x84EE) (#xCFA2 #x9023) (#xCFA3 #x932C) (#xCFA4 #x5442) (#xCFA5 #x9B6F) (#xCFA6 #x6AD3) (#xCFA7 #x7089) (#xCFA8 #x8CC2) (#xCFA9 #x8DEF) (#xCFAA #x9732) (#xCFAB #x52B4) (#xCFAC #x5A41) (#xCFAD #x5ECA) (#xCFAE #x5F04) (#xCFAF #x6717) (#xCFB0 #x697C) (#xCFB1 #x6994) (#xCFB2 #x6D6A) (#xCFB3 #x6F0F) (#xCFB4 #x7262) (#xCFB5 #x72FC) (#xCFB6 #x7BED) (#xCFB7 #x8001) (#xCFB8 #x807E) (#xCFB9 #x874B) (#xCFBA #x90CE) (#xCFBB #x516D) (#xCFBC #x9E93) (#xCFBD #x7984) (#xCFBE #x808B) (#xCFBF #x9332) (#xCFC0 #x8AD6) (#xCFC1 #x502D) (#xCFC2 #x548C) (#xCFC3 #x8A71) (#xCFC4 #x6B6A) (#xCFC5 #x8CC4) (#xCFC6 #x8107) (#xCFC7 #x60D1) (#xCFC8 #x67A0) (#xCFC9 #x9DF2) (#xCFCA #x4E99) (#xCFCB #x4E98) (#xCFCC #x9C10) (#xCFCD #x8A6B) (#xCFCE #x85C1) (#xCFCF #x8568) (#xCFD0 #x6900) (#xCFD1 #x6E7E) (#xCFD2 #x7897) (#xCFD3 #x8155) (#xD0A1 #x5F0C) (#xD0A2 #x4E10) (#xD0A3 #x4E15) (#xD0A4 #x4E2A) (#xD0A5 #x4E31) (#xD0A6 #x4E36) (#xD0A7 #x4E3C) (#xD0A8 #x4E3F) (#xD0A9 #x4E42) (#xD0AA #x4E56) (#xD0AB #x4E58) (#xD0AC #x4E82) (#xD0AD #x4E85) (#xD0AE #x8C6B) (#xD0AF #x4E8A) (#xD0B0 #x8212) (#xD0B1 #x5F0D) (#xD0B2 #x4E8E) (#xD0B3 #x4E9E) (#xD0B4 #x4E9F) (#xD0B5 #x4EA0) (#xD0B6 #x4EA2) (#xD0B7 #x4EB0) (#xD0B8 #x4EB3) (#xD0B9 #x4EB6) (#xD0BA #x4ECE) (#xD0BB #x4ECD) (#xD0BC #x4EC4) (#xD0BD #x4EC6) (#xD0BE #x4EC2) (#xD0BF #x4ED7) (#xD0C0 #x4EDE) (#xD0C1 #x4EED) (#xD0C2 #x4EDF) (#xD0C3 #x4EF7) (#xD0C4 #x4F09) (#xD0C5 #x4F5A) (#xD0C6 #x4F30) (#xD0C7 #x4F5B) (#xD0C8 #x4F5D) (#xD0C9 #x4F57) (#xD0CA #x4F47) (#xD0CB #x4F76) (#xD0CC #x4F88) (#xD0CD #x4F8F) (#xD0CE #x4F98) (#xD0CF #x4F7B) (#xD0D0 #x4F69) (#xD0D1 #x4F70) (#xD0D2 #x4F91) (#xD0D3 #x4F6F) (#xD0D4 #x4F86) (#xD0D5 #x4F96) (#xD0D6 #x5118) (#xD0D7 #x4FD4) (#xD0D8 #x4FDF) (#xD0D9 #x4FCE) (#xD0DA #x4FD8) (#xD0DB #x4FDB) (#xD0DC #x4FD1) (#xD0DD #x4FDA) (#xD0DE #x4FD0) (#xD0DF #x4FE4) (#xD0E0 #x4FE5) (#xD0E1 #x501A) (#xD0E2 #x5028) (#xD0E3 #x5014) (#xD0E4 #x502A) (#xD0E5 #x5025) (#xD0E6 #x5005) (#xD0E7 #x4F1C) (#xD0E8 #x4FF6) (#xD0E9 #x5021) (#xD0EA #x5029) (#xD0EB #x502C) (#xD0EC #x4FFE) (#xD0ED #x4FEF) (#xD0EE #x5011) (#xD0EF #x5006) (#xD0F0 #x5043) (#xD0F1 #x5047) (#xD0F2 #x6703) (#xD0F3 #x5055) (#xD0F4 #x5050) (#xD0F5 #x5048) (#xD0F6 #x505A) (#xD0F7 #x5056) (#xD0F8 #x506C) (#xD0F9 #x5078) (#xD0FA #x5080) (#xD0FB #x509A) (#xD0FC #x5085) (#xD0FD #x50B4) (#xD0FE #x50B2) (#xD1A1 #x50C9) (#xD1A2 #x50CA) (#xD1A3 #x50B3) (#xD1A4 #x50C2) (#xD1A5 #x50D6) (#xD1A6 #x50DE) (#xD1A7 #x50E5) (#xD1A8 #x50ED) (#xD1A9 #x50E3) (#xD1AA #x50EE) (#xD1AB #x50F9) (#xD1AC #x50F5) (#xD1AD #x5109) (#xD1AE #x5101) (#xD1AF #x5102) (#xD1B0 #x5116) (#xD1B1 #x5115) (#xD1B2 #x5114) (#xD1B3 #x511A) (#xD1B4 #x5121) (#xD1B5 #x513A) (#xD1B6 #x5137) (#xD1B7 #x513C) (#xD1B8 #x513B) (#xD1B9 #x513F) (#xD1BA #x5140) (#xD1BB #x5152) (#xD1BC #x514C) (#xD1BD #x5154) (#xD1BE #x5162) (#xD1BF #x7AF8) (#xD1C0 #x5169) (#xD1C1 #x516A) (#xD1C2 #x516E) (#xD1C3 #x5180) (#xD1C4 #x5182) (#xD1C5 #x56D8) (#xD1C6 #x518C) (#xD1C7 #x5189) (#xD1C8 #x518F) (#xD1C9 #x5191) (#xD1CA #x5193) (#xD1CB #x5195) (#xD1CC #x5196) (#xD1CD #x51A4) (#xD1CE #x51A6) (#xD1CF #x51A2) (#xD1D0 #x51A9) (#xD1D1 #x51AA) (#xD1D2 #x51AB) (#xD1D3 #x51B3) (#xD1D4 #x51B1) (#xD1D5 #x51B2) (#xD1D6 #x51B0) (#xD1D7 #x51B5) (#xD1D8 #x51BD) (#xD1D9 #x51C5) (#xD1DA #x51C9) (#xD1DB #x51DB) (#xD1DC #x51E0) (#xD1DD #x8655) (#xD1DE #x51E9) (#xD1DF #x51ED) (#xD1E0 #x51F0) (#xD1E1 #x51F5) (#xD1E2 #x51FE) (#xD1E3 #x5204) (#xD1E4 #x520B) (#xD1E5 #x5214) (#xD1E6 #x520E) (#xD1E7 #x5227) (#xD1E8 #x522A) (#xD1E9 #x522E) (#xD1EA #x5233) (#xD1EB #x5239) (#xD1EC #x524F) (#xD1ED #x5244) (#xD1EE #x524B) (#xD1EF #x524C) (#xD1F0 #x525E) (#xD1F1 #x5254) (#xD1F2 #x526A) (#xD1F3 #x5274) (#xD1F4 #x5269) (#xD1F5 #x5273) (#xD1F6 #x527F) (#xD1F7 #x527D) (#xD1F8 #x528D) (#xD1F9 #x5294) (#xD1FA #x5292) (#xD1FB #x5271) (#xD1FC #x5288) (#xD1FD #x5291) (#xD1FE #x8FA8) (#xD2A1 #x8FA7) (#xD2A2 #x52AC) (#xD2A3 #x52AD) (#xD2A4 #x52BC) (#xD2A5 #x52B5) (#xD2A6 #x52C1) (#xD2A7 #x52CD) (#xD2A8 #x52D7) (#xD2A9 #x52DE) (#xD2AA #x52E3) (#xD2AB #x52E6) (#xD2AC #x98ED) (#xD2AD #x52E0) (#xD2AE #x52F3) (#xD2AF #x52F5) (#xD2B0 #x52F8) (#xD2B1 #x52F9) (#xD2B2 #x5306) (#xD2B3 #x5308) (#xD2B4 #x7538) (#xD2B5 #x530D) (#xD2B6 #x5310) (#xD2B7 #x530F) (#xD2B8 #x5315) (#xD2B9 #x531A) (#xD2BA #x5323) (#xD2BB #x532F) (#xD2BC #x5331) (#xD2BD #x5333) (#xD2BE #x5338) (#xD2BF #x5340) (#xD2C0 #x5346) (#xD2C1 #x5345) (#xD2C2 #x4E17) (#xD2C3 #x5349) (#xD2C4 #x534D) (#xD2C5 #x51D6) (#xD2C6 #x535E) (#xD2C7 #x5369) (#xD2C8 #x536E) (#xD2C9 #x5918) (#xD2CA #x537B) (#xD2CB #x5377) (#xD2CC #x5382) (#xD2CD #x5396) (#xD2CE #x53A0) (#xD2CF #x53A6) (#xD2D0 #x53A5) (#xD2D1 #x53AE) (#xD2D2 #x53B0) (#xD2D3 #x53B6) (#xD2D4 #x53C3) (#xD2D5 #x7C12) (#xD2D6 #x96D9) (#xD2D7 #x53DF) (#xD2D8 #x66FC) (#xD2D9 #x71EE) (#xD2DA #x53EE) (#xD2DB #x53E8) (#xD2DC #x53ED) (#xD2DD #x53FA) (#xD2DE #x5401) (#xD2DF #x543D) (#xD2E0 #x5440) (#xD2E1 #x542C) (#xD2E2 #x542D) (#xD2E3 #x543C) (#xD2E4 #x542E) (#xD2E5 #x5436) (#xD2E6 #x5429) (#xD2E7 #x541D) (#xD2E8 #x544E) (#xD2E9 #x548F) (#xD2EA #x5475) (#xD2EB #x548E) (#xD2EC #x545F) (#xD2ED #x5471) (#xD2EE #x5477) (#xD2EF #x5470) (#xD2F0 #x5492) (#xD2F1 #x547B) (#xD2F2 #x5480) (#xD2F3 #x5476) (#xD2F4 #x5484) (#xD2F5 #x5490) (#xD2F6 #x5486) (#xD2F7 #x54C7) (#xD2F8 #x54A2) (#xD2F9 #x54B8) (#xD2FA #x54A5) (#xD2FB #x54AC) (#xD2FC #x54C4) (#xD2FD #x54C8) (#xD2FE #x54A8) (#xD3A1 #x54AB) (#xD3A2 #x54C2) (#xD3A3 #x54A4) (#xD3A4 #x54BE) (#xD3A5 #x54BC) (#xD3A6 #x54D8) (#xD3A7 #x54E5) (#xD3A8 #x54E6) (#xD3A9 #x550F) (#xD3AA #x5514) (#xD3AB #x54FD) (#xD3AC #x54EE) (#xD3AD #x54ED) (#xD3AE #x54FA) (#xD3AF #x54E2) (#xD3B0 #x5539) (#xD3B1 #x5540) (#xD3B2 #x5563) (#xD3B3 #x554C) (#xD3B4 #x552E) (#xD3B5 #x555C) (#xD3B6 #x5545) (#xD3B7 #x5556) (#xD3B8 #x5557) (#xD3B9 #x5538) (#xD3BA #x5533) (#xD3BB #x555D) (#xD3BC #x5599) (#xD3BD #x5580) (#xD3BE #x54AF) (#xD3BF #x558A) (#xD3C0 #x559F) (#xD3C1 #x557B) (#xD3C2 #x557E) (#xD3C3 #x5598) (#xD3C4 #x559E) (#xD3C5 #x55AE) (#xD3C6 #x557C) (#xD3C7 #x5583) (#xD3C8 #x55A9) (#xD3C9 #x5587) (#xD3CA #x55A8) (#xD3CB #x55DA) (#xD3CC #x55C5) (#xD3CD #x55DF) (#xD3CE #x55C4) (#xD3CF #x55DC) (#xD3D0 #x55E4) (#xD3D1 #x55D4) (#xD3D2 #x5614) (#xD3D3 #x55F7) (#xD3D4 #x5616) (#xD3D5 #x55FE) (#xD3D6 #x55FD) (#xD3D7 #x561B) (#xD3D8 #x55F9) (#xD3D9 #x564E) (#xD3DA #x5650) (#xD3DB #x71DF) (#xD3DC #x5634) (#xD3DD #x5636) (#xD3DE #x5632) (#xD3DF #x5638) (#xD3E0 #x566B) (#xD3E1 #x5664) (#xD3E2 #x562F) (#xD3E3 #x566C) (#xD3E4 #x566A) (#xD3E5 #x5686) (#xD3E6 #x5680) (#xD3E7 #x568A) (#xD3E8 #x56A0) (#xD3E9 #x5694) (#xD3EA #x568F) (#xD3EB #x56A5) (#xD3EC #x56AE) (#xD3ED #x56B6) (#xD3EE #x56B4) (#xD3EF #x56C2) (#xD3F0 #x56BC) (#xD3F1 #x56C1) (#xD3F2 #x56C3) (#xD3F3 #x56C0) (#xD3F4 #x56C8) (#xD3F5 #x56CE) (#xD3F6 #x56D1) (#xD3F7 #x56D3) (#xD3F8 #x56D7) (#xD3F9 #x56EE) (#xD3FA #x56F9) (#xD3FB #x5700) (#xD3FC #x56FF) (#xD3FD #x5704) (#xD3FE #x5709) (#xD4A1 #x5708) (#xD4A2 #x570B) (#xD4A3 #x570D) (#xD4A4 #x5713) (#xD4A5 #x5718) (#xD4A6 #x5716) (#xD4A7 #x55C7) (#xD4A8 #x571C) (#xD4A9 #x5726) (#xD4AA #x5737) (#xD4AB #x5738) (#xD4AC #x574E) (#xD4AD #x573B) (#xD4AE #x5740) (#xD4AF #x574F) (#xD4B0 #x5769) (#xD4B1 #x57C0) (#xD4B2 #x5788) (#xD4B3 #x5761) (#xD4B4 #x577F) (#xD4B5 #x5789) (#xD4B6 #x5793) (#xD4B7 #x57A0) (#xD4B8 #x57B3) (#xD4B9 #x57A4) (#xD4BA #x57AA) (#xD4BB #x57B0) (#xD4BC #x57C3) (#xD4BD #x57C6) (#xD4BE #x57D4) (#xD4BF #x57D2) (#xD4C0 #x57D3) (#xD4C1 #x580A) (#xD4C2 #x57D6) (#xD4C3 #x57E3) (#xD4C4 #x580B) (#xD4C5 #x5819) (#xD4C6 #x581D) (#xD4C7 #x5872) (#xD4C8 #x5821) (#xD4C9 #x5862) (#xD4CA #x584B) (#xD4CB #x5870) (#xD4CC #x6BC0) (#xD4CD #x5852) (#xD4CE #x583D) (#xD4CF #x5879) (#xD4D0 #x5885) (#xD4D1 #x58B9) (#xD4D2 #x589F) (#xD4D3 #x58AB) (#xD4D4 #x58BA) (#xD4D5 #x58DE) (#xD4D6 #x58BB) (#xD4D7 #x58B8) (#xD4D8 #x58AE) (#xD4D9 #x58C5) (#xD4DA #x58D3) (#xD4DB #x58D1) (#xD4DC #x58D7) (#xD4DD #x58D9) (#xD4DE #x58D8) (#xD4DF #x58E5) (#xD4E0 #x58DC) (#xD4E1 #x58E4) (#xD4E2 #x58DF) (#xD4E3 #x58EF) (#xD4E4 #x58FA) (#xD4E5 #x58F9) (#xD4E6 #x58FB) (#xD4E7 #x58FC) (#xD4E8 #x58FD) (#xD4E9 #x5902) (#xD4EA #x590A) (#xD4EB #x5910) (#xD4EC #x591B) (#xD4ED #x68A6) (#xD4EE #x5925) (#xD4EF #x592C) (#xD4F0 #x592D) (#xD4F1 #x5932) (#xD4F2 #x5938) (#xD4F3 #x593E) (#xD4F4 #x7AD2) (#xD4F5 #x5955) (#xD4F6 #x5950) (#xD4F7 #x594E) (#xD4F8 #x595A) (#xD4F9 #x5958) (#xD4FA #x5962) (#xD4FB #x5960) (#xD4FC #x5967) (#xD4FD #x596C) (#xD4FE #x5969) (#xD5A1 #x5978) (#xD5A2 #x5981) (#xD5A3 #x599D) (#xD5A4 #x4F5E) (#xD5A5 #x4FAB) (#xD5A6 #x59A3) (#xD5A7 #x59B2) (#xD5A8 #x59C6) (#xD5A9 #x59E8) (#xD5AA #x59DC) (#xD5AB #x598D) (#xD5AC #x59D9) (#xD5AD #x59DA) (#xD5AE #x5A25) (#xD5AF #x5A1F) (#xD5B0 #x5A11) (#xD5B1 #x5A1C) (#xD5B2 #x5A09) (#xD5B3 #x5A1A) (#xD5B4 #x5A40) (#xD5B5 #x5A6C) (#xD5B6 #x5A49) (#xD5B7 #x5A35) (#xD5B8 #x5A36) (#xD5B9 #x5A62) (#xD5BA #x5A6A) (#xD5BB #x5A9A) (#xD5BC #x5ABC) (#xD5BD #x5ABE) (#xD5BE #x5ACB) (#xD5BF #x5AC2) (#xD5C0 #x5ABD) (#xD5C1 #x5AE3) (#xD5C2 #x5AD7) (#xD5C3 #x5AE6) (#xD5C4 #x5AE9) (#xD5C5 #x5AD6) (#xD5C6 #x5AFA) (#xD5C7 #x5AFB) (#xD5C8 #x5B0C) (#xD5C9 #x5B0B) (#xD5CA #x5B16) (#xD5CB #x5B32) (#xD5CC #x5AD0) (#xD5CD #x5B2A) (#xD5CE #x5B36) (#xD5CF #x5B3E) (#xD5D0 #x5B43) (#xD5D1 #x5B45) (#xD5D2 #x5B40) (#xD5D3 #x5B51) (#xD5D4 #x5B55) (#xD5D5 #x5B5A) (#xD5D6 #x5B5B) (#xD5D7 #x5B65) (#xD5D8 #x5B69) (#xD5D9 #x5B70) (#xD5DA #x5B73) (#xD5DB #x5B75) (#xD5DC #x5B78) (#xD5DD #x6588) (#xD5DE #x5B7A) (#xD5DF #x5B80) (#xD5E0 #x5B83) (#xD5E1 #x5BA6) (#xD5E2 #x5BB8) (#xD5E3 #x5BC3) (#xD5E4 #x5BC7) (#xD5E5 #x5BC9) (#xD5E6 #x5BD4) (#xD5E7 #x5BD0) (#xD5E8 #x5BE4) (#xD5E9 #x5BE6) (#xD5EA #x5BE2) (#xD5EB #x5BDE) (#xD5EC #x5BE5) (#xD5ED #x5BEB) (#xD5EE #x5BF0) (#xD5EF #x5BF6) (#xD5F0 #x5BF3) (#xD5F1 #x5C05) (#xD5F2 #x5C07) (#xD5F3 #x5C08) (#xD5F4 #x5C0D) (#xD5F5 #x5C13) (#xD5F6 #x5C20) (#xD5F7 #x5C22) (#xD5F8 #x5C28) (#xD5F9 #x5C38) (#xD5FA #x5C39) (#xD5FB #x5C41) (#xD5FC #x5C46) (#xD5FD #x5C4E) (#xD5FE #x5C53) (#xD6A1 #x5C50) (#xD6A2 #x5C4F) (#xD6A3 #x5B71) (#xD6A4 #x5C6C) (#xD6A5 #x5C6E) (#xD6A6 #x4E62) (#xD6A7 #x5C76) (#xD6A8 #x5C79) (#xD6A9 #x5C8C) (#xD6AA #x5C91) (#xD6AB #x5C94) (#xD6AC #x599B) (#xD6AD #x5CAB) (#xD6AE #x5CBB) (#xD6AF #x5CB6) (#xD6B0 #x5CBC) (#xD6B1 #x5CB7) (#xD6B2 #x5CC5) (#xD6B3 #x5CBE) (#xD6B4 #x5CC7) (#xD6B5 #x5CD9) (#xD6B6 #x5CE9) (#xD6B7 #x5CFD) (#xD6B8 #x5CFA) (#xD6B9 #x5CED) (#xD6BA #x5D8C) (#xD6BB #x5CEA) (#xD6BC #x5D0B) (#xD6BD #x5D15) (#xD6BE #x5D17) (#xD6BF #x5D5C) (#xD6C0 #x5D1F) (#xD6C1 #x5D1B) (#xD6C2 #x5D11) (#xD6C3 #x5D14) (#xD6C4 #x5D22) (#xD6C5 #x5D1A) (#xD6C6 #x5D19) (#xD6C7 #x5D18) (#xD6C8 #x5D4C) (#xD6C9 #x5D52) (#xD6CA #x5D4E) (#xD6CB #x5D4B) (#xD6CC #x5D6C) (#xD6CD #x5D73) (#xD6CE #x5D76) (#xD6CF #x5D87) (#xD6D0 #x5D84) (#xD6D1 #x5D82) (#xD6D2 #x5DA2) (#xD6D3 #x5D9D) (#xD6D4 #x5DAC) (#xD6D5 #x5DAE) (#xD6D6 #x5DBD) (#xD6D7 #x5D90) (#xD6D8 #x5DB7) (#xD6D9 #x5DBC) (#xD6DA #x5DC9) (#xD6DB #x5DCD) (#xD6DC #x5DD3) (#xD6DD #x5DD2) (#xD6DE #x5DD6) (#xD6DF #x5DDB) (#xD6E0 #x5DEB) (#xD6E1 #x5DF2) (#xD6E2 #x5DF5) (#xD6E3 #x5E0B) (#xD6E4 #x5E1A) (#xD6E5 #x5E19) (#xD6E6 #x5E11) (#xD6E7 #x5E1B) (#xD6E8 #x5E36) (#xD6E9 #x5E37) (#xD6EA #x5E44) (#xD6EB #x5E43) (#xD6EC #x5E40) (#xD6ED #x5E4E) (#xD6EE #x5E57) (#xD6EF #x5E54) (#xD6F0 #x5E5F) (#xD6F1 #x5E62) (#xD6F2 #x5E64) (#xD6F3 #x5E47) (#xD6F4 #x5E75) (#xD6F5 #x5E76) (#xD6F6 #x5E7A) (#xD6F7 #x9EBC) (#xD6F8 #x5E7F) (#xD6F9 #x5EA0) (#xD6FA #x5EC1) (#xD6FB #x5EC2) (#xD6FC #x5EC8) (#xD6FD #x5ED0) (#xD6FE #x5ECF) (#xD7A1 #x5ED6) (#xD7A2 #x5EE3) (#xD7A3 #x5EDD) (#xD7A4 #x5EDA) (#xD7A5 #x5EDB) (#xD7A6 #x5EE2) (#xD7A7 #x5EE1) (#xD7A8 #x5EE8) (#xD7A9 #x5EE9) (#xD7AA #x5EEC) (#xD7AB #x5EF1) (#xD7AC #x5EF3) (#xD7AD #x5EF0) (#xD7AE #x5EF4) (#xD7AF #x5EF8) (#xD7B0 #x5EFE) (#xD7B1 #x5F03) (#xD7B2 #x5F09) (#xD7B3 #x5F5D) (#xD7B4 #x5F5C) (#xD7B5 #x5F0B) (#xD7B6 #x5F11) (#xD7B7 #x5F16) (#xD7B8 #x5F29) (#xD7B9 #x5F2D) (#xD7BA #x5F38) (#xD7BB #x5F41) (#xD7BC #x5F48) (#xD7BD #x5F4C) (#xD7BE #x5F4E) (#xD7BF #x5F2F) (#xD7C0 #x5F51) (#xD7C1 #x5F56) (#xD7C2 #x5F57) (#xD7C3 #x5F59) (#xD7C4 #x5F61) (#xD7C5 #x5F6D) (#xD7C6 #x5F73) (#xD7C7 #x5F77) (#xD7C8 #x5F83) (#xD7C9 #x5F82) (#xD7CA #x5F7F) (#xD7CB #x5F8A) (#xD7CC #x5F88) (#xD7CD #x5F91) (#xD7CE #x5F87) (#xD7CF #x5F9E) (#xD7D0 #x5F99) (#xD7D1 #x5F98) (#xD7D2 #x5FA0) (#xD7D3 #x5FA8) (#xD7D4 #x5FAD) (#xD7D5 #x5FBC) (#xD7D6 #x5FD6) (#xD7D7 #x5FFB) (#xD7D8 #x5FE4) (#xD7D9 #x5FF8) (#xD7DA #x5FF1) (#xD7DB #x5FDD) (#xD7DC #x60B3) (#xD7DD #x5FFF) (#xD7DE #x6021) (#xD7DF #x6060) (#xD7E0 #x6019) (#xD7E1 #x6010) (#xD7E2 #x6029) (#xD7E3 #x600E) (#xD7E4 #x6031) (#xD7E5 #x601B) (#xD7E6 #x6015) (#xD7E7 #x602B) (#xD7E8 #x6026) (#xD7E9 #x600F) (#xD7EA #x603A) (#xD7EB #x605A) (#xD7EC #x6041) (#xD7ED #x606A) (#xD7EE #x6077) (#xD7EF #x605F) (#xD7F0 #x604A) (#xD7F1 #x6046) (#xD7F2 #x604D) (#xD7F3 #x6063) (#xD7F4 #x6043) (#xD7F5 #x6064) (#xD7F6 #x6042) (#xD7F7 #x606C) (#xD7F8 #x606B) (#xD7F9 #x6059) (#xD7FA #x6081) (#xD7FB #x608D) (#xD7FC #x60E7) (#xD7FD #x6083) (#xD7FE #x609A) (#xD8A1 #x6084) (#xD8A2 #x609B) (#xD8A3 #x6096) (#xD8A4 #x6097) (#xD8A5 #x6092) (#xD8A6 #x60A7) (#xD8A7 #x608B) (#xD8A8 #x60E1) (#xD8A9 #x60B8) (#xD8AA #x60E0) (#xD8AB #x60D3) (#xD8AC #x60B4) (#xD8AD #x5FF0) (#xD8AE #x60BD) (#xD8AF #x60C6) (#xD8B0 #x60B5) (#xD8B1 #x60D8) (#xD8B2 #x614D) (#xD8B3 #x6115) (#xD8B4 #x6106) (#xD8B5 #x60F6) (#xD8B6 #x60F7) (#xD8B7 #x6100) (#xD8B8 #x60F4) (#xD8B9 #x60FA) (#xD8BA #x6103) (#xD8BB #x6121) (#xD8BC #x60FB) (#xD8BD #x60F1) (#xD8BE #x610D) (#xD8BF #x610E) (#xD8C0 #x6147) (#xD8C1 #x613E) (#xD8C2 #x6128) (#xD8C3 #x6127) (#xD8C4 #x614A) (#xD8C5 #x613F) (#xD8C6 #x613C) (#xD8C7 #x612C) (#xD8C8 #x6134) (#xD8C9 #x613D) (#xD8CA #x6142) (#xD8CB #x6144) (#xD8CC #x6173) (#xD8CD #x6177) (#xD8CE #x6158) (#xD8CF #x6159) (#xD8D0 #x615A) (#xD8D1 #x616B) (#xD8D2 #x6174) (#xD8D3 #x616F) (#xD8D4 #x6165) (#xD8D5 #x6171) (#xD8D6 #x615F) (#xD8D7 #x615D) (#xD8D8 #x6153) (#xD8D9 #x6175) (#xD8DA #x6199) (#xD8DB #x6196) (#xD8DC #x6187) (#xD8DD #x61AC) (#xD8DE #x6194) (#xD8DF #x619A) (#xD8E0 #x618A) (#xD8E1 #x6191) (#xD8E2 #x61AB) (#xD8E3 #x61AE) (#xD8E4 #x61CC) (#xD8E5 #x61CA) (#xD8E6 #x61C9) (#xD8E7 #x61F7) (#xD8E8 #x61C8) (#xD8E9 #x61C3) (#xD8EA #x61C6) (#xD8EB #x61BA) (#xD8EC #x61CB) (#xD8ED #x7F79) (#xD8EE #x61CD) (#xD8EF #x61E6) (#xD8F0 #x61E3) (#xD8F1 #x61F6) (#xD8F2 #x61FA) (#xD8F3 #x61F4) (#xD8F4 #x61FF) (#xD8F5 #x61FD) (#xD8F6 #x61FC) (#xD8F7 #x61FE) (#xD8F8 #x6200) (#xD8F9 #x6208) (#xD8FA #x6209) (#xD8FB #x620D) (#xD8FC #x620C) (#xD8FD #x6214) (#xD8FE #x621B) (#xD9A1 #x621E) (#xD9A2 #x6221) (#xD9A3 #x622A) (#xD9A4 #x622E) (#xD9A5 #x6230) (#xD9A6 #x6232) (#xD9A7 #x6233) (#xD9A8 #x6241) (#xD9A9 #x624E) (#xD9AA #x625E) (#xD9AB #x6263) (#xD9AC #x625B) (#xD9AD #x6260) (#xD9AE #x6268) (#xD9AF #x627C) (#xD9B0 #x6282) (#xD9B1 #x6289) (#xD9B2 #x627E) (#xD9B3 #x6292) (#xD9B4 #x6293) (#xD9B5 #x6296) (#xD9B6 #x62D4) (#xD9B7 #x6283) (#xD9B8 #x6294) (#xD9B9 #x62D7) (#xD9BA #x62D1) (#xD9BB #x62BB) (#xD9BC #x62CF) (#xD9BD #x62FF) (#xD9BE #x62C6) (#xD9BF #x64D4) (#xD9C0 #x62C8) (#xD9C1 #x62DC) (#xD9C2 #x62CC) (#xD9C3 #x62CA) (#xD9C4 #x62C2) (#xD9C5 #x62C7) (#xD9C6 #x629B) (#xD9C7 #x62C9) (#xD9C8 #x630C) (#xD9C9 #x62EE) (#xD9CA #x62F1) (#xD9CB #x6327) (#xD9CC #x6302) (#xD9CD #x6308) (#xD9CE #x62EF) (#xD9CF #x62F5) (#xD9D0 #x6350) (#xD9D1 #x633E) (#xD9D2 #x634D) (#xD9D3 #x641C) (#xD9D4 #x634F) (#xD9D5 #x6396) (#xD9D6 #x638E) (#xD9D7 #x6380) (#xD9D8 #x63AB) (#xD9D9 #x6376) (#xD9DA #x63A3) (#xD9DB #x638F) (#xD9DC #x6389) (#xD9DD #x639F) (#xD9DE #x63B5) (#xD9DF #x636B) (#xD9E0 #x6369) (#xD9E1 #x63BE) (#xD9E2 #x63E9) (#xD9E3 #x63C0) (#xD9E4 #x63C6) (#xD9E5 #x63E3) (#xD9E6 #x63C9) (#xD9E7 #x63D2) (#xD9E8 #x63F6) (#xD9E9 #x63C4) (#xD9EA #x6416) (#xD9EB #x6434) (#xD9EC #x6406) (#xD9ED #x6413) (#xD9EE #x6426) (#xD9EF #x6436) (#xD9F0 #x651D) (#xD9F1 #x6417) (#xD9F2 #x6428) (#xD9F3 #x640F) (#xD9F4 #x6467) (#xD9F5 #x646F) (#xD9F6 #x6476) (#xD9F7 #x644E) (#xD9F8 #x652A) (#xD9F9 #x6495) (#xD9FA #x6493) (#xD9FB #x64A5) (#xD9FC #x64A9) (#xD9FD #x6488) (#xD9FE #x64BC) (#xDAA1 #x64DA) (#xDAA2 #x64D2) (#xDAA3 #x64C5) (#xDAA4 #x64C7) (#xDAA5 #x64BB) (#xDAA6 #x64D8) (#xDAA7 #x64C2) (#xDAA8 #x64F1) (#xDAA9 #x64E7) (#xDAAA #x8209) (#xDAAB #x64E0) (#xDAAC #x64E1) (#xDAAD #x62AC) (#xDAAE #x64E3) (#xDAAF #x64EF) (#xDAB0 #x652C) (#xDAB1 #x64F6) (#xDAB2 #x64F4) (#xDAB3 #x64F2) (#xDAB4 #x64FA) (#xDAB5 #x6500) (#xDAB6 #x64FD) (#xDAB7 #x6518) (#xDAB8 #x651C) (#xDAB9 #x6505) (#xDABA #x6524) (#xDABB #x6523) (#xDABC #x652B) (#xDABD #x6534) (#xDABE #x6535) (#xDABF #x6537) (#xDAC0 #x6536) (#xDAC1 #x6538) (#xDAC2 #x754B) (#xDAC3 #x6548) (#xDAC4 #x6556) (#xDAC5 #x6555) (#xDAC6 #x654D) (#xDAC7 #x6558) (#xDAC8 #x655E) (#xDAC9 #x655D) (#xDACA #x6572) (#xDACB #x6578) (#xDACC #x6582) (#xDACD #x6583) (#xDACE #x8B8A) (#xDACF #x659B) (#xDAD0 #x659F) (#xDAD1 #x65AB) (#xDAD2 #x65B7) (#xDAD3 #x65C3) (#xDAD4 #x65C6) (#xDAD5 #x65C1) (#xDAD6 #x65C4) (#xDAD7 #x65CC) (#xDAD8 #x65D2) (#xDAD9 #x65DB) (#xDADA #x65D9) (#xDADB #x65E0) (#xDADC #x65E1) (#xDADD #x65F1) (#xDADE #x6772) (#xDADF #x660A) (#xDAE0 #x6603) (#xDAE1 #x65FB) (#xDAE2 #x6773) (#xDAE3 #x6635) (#xDAE4 #x6636) (#xDAE5 #x6634) (#xDAE6 #x661C) (#xDAE7 #x664F) (#xDAE8 #x6644) (#xDAE9 #x6649) (#xDAEA #x6641) (#xDAEB #x665E) (#xDAEC #x665D) (#xDAED #x6664) (#xDAEE #x6667) (#xDAEF #x6668) (#xDAF0 #x665F) (#xDAF1 #x6662) (#xDAF2 #x6670) (#xDAF3 #x6683) (#xDAF4 #x6688) (#xDAF5 #x668E) (#xDAF6 #x6689) (#xDAF7 #x6684) (#xDAF8 #x6698) (#xDAF9 #x669D) (#xDAFA #x66C1) (#xDAFB #x66B9) (#xDAFC #x66C9) (#xDAFD #x66BE) (#xDAFE #x66BC) (#xDBA1 #x66C4) (#xDBA2 #x66B8) (#xDBA3 #x66D6) (#xDBA4 #x66DA) (#xDBA5 #x66E0) (#xDBA6 #x663F) (#xDBA7 #x66E6) (#xDBA8 #x66E9) (#xDBA9 #x66F0) (#xDBAA #x66F5) (#xDBAB #x66F7) (#xDBAC #x670F) (#xDBAD #x6716) (#xDBAE #x671E) (#xDBAF #x6726) (#xDBB0 #x6727) (#xDBB1 #x9738) (#xDBB2 #x672E) (#xDBB3 #x673F) (#xDBB4 #x6736) (#xDBB5 #x6741) (#xDBB6 #x6738) (#xDBB7 #x6737) (#xDBB8 #x6746) (#xDBB9 #x675E) (#xDBBA #x6760) (#xDBBB #x6759) (#xDBBC #x6763) (#xDBBD #x6764) (#xDBBE #x6789) (#xDBBF #x6770) (#xDBC0 #x67A9) (#xDBC1 #x677C) (#xDBC2 #x676A) (#xDBC3 #x678C) (#xDBC4 #x678B) (#xDBC5 #x67A6) (#xDBC6 #x67A1) (#xDBC7 #x6785) (#xDBC8 #x67B7) (#xDBC9 #x67EF) (#xDBCA #x67B4) (#xDBCB #x67EC) (#xDBCC #x67B3) (#xDBCD #x67E9) (#xDBCE #x67B8) (#xDBCF #x67E4) (#xDBD0 #x67DE) (#xDBD1 #x67DD) (#xDBD2 #x67E2) (#xDBD3 #x67EE) (#xDBD4 #x67B9) (#xDBD5 #x67CE) (#xDBD6 #x67C6) (#xDBD7 #x67E7) (#xDBD8 #x6A9C) (#xDBD9 #x681E) (#xDBDA #x6846) (#xDBDB #x6829) (#xDBDC #x6840) (#xDBDD #x684D) (#xDBDE #x6832) (#xDBDF #x684E) (#xDBE0 #x68B3) (#xDBE1 #x682B) (#xDBE2 #x6859) (#xDBE3 #x6863) (#xDBE4 #x6877) (#xDBE5 #x687F) (#xDBE6 #x689F) (#xDBE7 #x688F) (#xDBE8 #x68AD) (#xDBE9 #x6894) (#xDBEA #x689D) (#xDBEB #x689B) (#xDBEC #x6883) (#xDBED #x6AAE) (#xDBEE #x68B9) (#xDBEF #x6874) (#xDBF0 #x68B5) (#xDBF1 #x68A0) (#xDBF2 #x68BA) (#xDBF3 #x690F) (#xDBF4 #x688D) (#xDBF5 #x687E) (#xDBF6 #x6901) (#xDBF7 #x68CA) (#xDBF8 #x6908) (#xDBF9 #x68D8) (#xDBFA #x6922) (#xDBFB #x6926) (#xDBFC #x68E1) (#xDBFD #x690C) (#xDBFE #x68CD) (#xDCA1 #x68D4) (#xDCA2 #x68E7) (#xDCA3 #x68D5) (#xDCA4 #x6936) (#xDCA5 #x6912) (#xDCA6 #x6904) (#xDCA7 #x68D7) (#xDCA8 #x68E3) (#xDCA9 #x6925) (#xDCAA #x68F9) (#xDCAB #x68E0) (#xDCAC #x68EF) (#xDCAD #x6928) (#xDCAE #x692A) (#xDCAF #x691A) (#xDCB0 #x6923) (#xDCB1 #x6921) (#xDCB2 #x68C6) (#xDCB3 #x6979) (#xDCB4 #x6977) (#xDCB5 #x695C) (#xDCB6 #x6978) (#xDCB7 #x696B) (#xDCB8 #x6954) (#xDCB9 #x697E) (#xDCBA #x696E) (#xDCBB #x6939) (#xDCBC #x6974) (#xDCBD #x693D) (#xDCBE #x6959) (#xDCBF #x6930) (#xDCC0 #x6961) (#xDCC1 #x695E) (#xDCC2 #x695D) (#xDCC3 #x6981) (#xDCC4 #x696A) (#xDCC5 #x69B2) (#xDCC6 #x69AE) (#xDCC7 #x69D0) (#xDCC8 #x69BF) (#xDCC9 #x69C1) (#xDCCA #x69D3) (#xDCCB #x69BE) (#xDCCC #x69CE) (#xDCCD #x5BE8) (#xDCCE #x69CA) (#xDCCF #x69DD) (#xDCD0 #x69BB) (#xDCD1 #x69C3) (#xDCD2 #x69A7) (#xDCD3 #x6A2E) (#xDCD4 #x6991) (#xDCD5 #x69A0) (#xDCD6 #x699C) (#xDCD7 #x6995) (#xDCD8 #x69B4) (#xDCD9 #x69DE) (#xDCDA #x69E8) (#xDCDB #x6A02) (#xDCDC #x6A1B) (#xDCDD #x69FF) (#xDCDE #x6B0A) (#xDCDF #x69F9) (#xDCE0 #x69F2) (#xDCE1 #x69E7) (#xDCE2 #x6A05) (#xDCE3 #x69B1) (#xDCE4 #x6A1E) (#xDCE5 #x69ED) (#xDCE6 #x6A14) (#xDCE7 #x69EB) (#xDCE8 #x6A0A) (#xDCE9 #x6A12) (#xDCEA #x6AC1) (#xDCEB #x6A23) (#xDCEC #x6A13) (#xDCED #x6A44) (#xDCEE #x6A0C) (#xDCEF #x6A72) (#xDCF0 #x6A36) (#xDCF1 #x6A78) (#xDCF2 #x6A47) (#xDCF3 #x6A62) (#xDCF4 #x6A59) (#xDCF5 #x6A66) (#xDCF6 #x6A48) (#xDCF7 #x6A38) (#xDCF8 #x6A22) (#xDCF9 #x6A90) (#xDCFA #x6A8D) (#xDCFB #x6AA0) (#xDCFC #x6A84) (#xDCFD #x6AA2) (#xDCFE #x6AA3) (#xDDA1 #x6A97) (#xDDA2 #x8617) (#xDDA3 #x6ABB) (#xDDA4 #x6AC3) (#xDDA5 #x6AC2) (#xDDA6 #x6AB8) (#xDDA7 #x6AB3) (#xDDA8 #x6AAC) (#xDDA9 #x6ADE) (#xDDAA #x6AD1) (#xDDAB #x6ADF) (#xDDAC #x6AAA) (#xDDAD #x6ADA) (#xDDAE #x6AEA) (#xDDAF #x6AFB) (#xDDB0 #x6B05) (#xDDB1 #x8616) (#xDDB2 #x6AFA) (#xDDB3 #x6B12) (#xDDB4 #x6B16) (#xDDB5 #x9B31) (#xDDB6 #x6B1F) (#xDDB7 #x6B38) (#xDDB8 #x6B37) (#xDDB9 #x76DC) (#xDDBA #x6B39) (#xDDBB #x98EE) (#xDDBC #x6B47) (#xDDBD #x6B43) (#xDDBE #x6B49) (#xDDBF #x6B50) (#xDDC0 #x6B59) (#xDDC1 #x6B54) (#xDDC2 #x6B5B) (#xDDC3 #x6B5F) (#xDDC4 #x6B61) (#xDDC5 #x6B78) (#xDDC6 #x6B79) (#xDDC7 #x6B7F) (#xDDC8 #x6B80) (#xDDC9 #x6B84) (#xDDCA #x6B83) (#xDDCB #x6B8D) (#xDDCC #x6B98) (#xDDCD #x6B95) (#xDDCE #x6B9E) (#xDDCF #x6BA4) (#xDDD0 #x6BAA) (#xDDD1 #x6BAB) (#xDDD2 #x6BAF) (#xDDD3 #x6BB2) (#xDDD4 #x6BB1) (#xDDD5 #x6BB3) (#xDDD6 #x6BB7) (#xDDD7 #x6BBC) (#xDDD8 #x6BC6) (#xDDD9 #x6BCB) (#xDDDA #x6BD3) (#xDDDB #x6BDF) (#xDDDC #x6BEC) (#xDDDD #x6BEB) (#xDDDE #x6BF3) (#xDDDF #x6BEF) (#xDDE0 #x9EBE) (#xDDE1 #x6C08) (#xDDE2 #x6C13) (#xDDE3 #x6C14) (#xDDE4 #x6C1B) (#xDDE5 #x6C24) (#xDDE6 #x6C23) (#xDDE7 #x6C5E) (#xDDE8 #x6C55) (#xDDE9 #x6C62) (#xDDEA #x6C6A) (#xDDEB #x6C82) (#xDDEC #x6C8D) (#xDDED #x6C9A) (#xDDEE #x6C81) (#xDDEF #x6C9B) (#xDDF0 #x6C7E) (#xDDF1 #x6C68) (#xDDF2 #x6C73) (#xDDF3 #x6C92) (#xDDF4 #x6C90) (#xDDF5 #x6CC4) (#xDDF6 #x6CF1) (#xDDF7 #x6CD3) (#xDDF8 #x6CBD) (#xDDF9 #x6CD7) (#xDDFA #x6CC5) (#xDDFB #x6CDD) (#xDDFC #x6CAE) (#xDDFD #x6CB1) (#xDDFE #x6CBE) (#xDEA1 #x6CBA) (#xDEA2 #x6CDB) (#xDEA3 #x6CEF) (#xDEA4 #x6CD9) (#xDEA5 #x6CEA) (#xDEA6 #x6D1F) (#xDEA7 #x884D) (#xDEA8 #x6D36) (#xDEA9 #x6D2B) (#xDEAA #x6D3D) (#xDEAB #x6D38) (#xDEAC #x6D19) (#xDEAD #x6D35) (#xDEAE #x6D33) (#xDEAF #x6D12) (#xDEB0 #x6D0C) (#xDEB1 #x6D63) (#xDEB2 #x6D93) (#xDEB3 #x6D64) (#xDEB4 #x6D5A) (#xDEB5 #x6D79) (#xDEB6 #x6D59) (#xDEB7 #x6D8E) (#xDEB8 #x6D95) (#xDEB9 #x6FE4) (#xDEBA #x6D85) (#xDEBB #x6DF9) (#xDEBC #x6E15) (#xDEBD #x6E0A) (#xDEBE #x6DB5) (#xDEBF #x6DC7) (#xDEC0 #x6DE6) (#xDEC1 #x6DB8) (#xDEC2 #x6DC6) (#xDEC3 #x6DEC) (#xDEC4 #x6DDE) (#xDEC5 #x6DCC) (#xDEC6 #x6DE8) (#xDEC7 #x6DD2) (#xDEC8 #x6DC5) (#xDEC9 #x6DFA) (#xDECA #x6DD9) (#xDECB #x6DE4) (#xDECC #x6DD5) (#xDECD #x6DEA) (#xDECE #x6DEE) (#xDECF #x6E2D) (#xDED0 #x6E6E) (#xDED1 #x6E2E) (#xDED2 #x6E19) (#xDED3 #x6E72) (#xDED4 #x6E5F) (#xDED5 #x6E3E) (#xDED6 #x6E23) (#xDED7 #x6E6B) (#xDED8 #x6E2B) (#xDED9 #x6E76) (#xDEDA #x6E4D) (#xDEDB #x6E1F) (#xDEDC #x6E43) (#xDEDD #x6E3A) (#xDEDE #x6E4E) (#xDEDF #x6E24) (#xDEE0 #x6EFF) (#xDEE1 #x6E1D) (#xDEE2 #x6E38) (#xDEE3 #x6E82) (#xDEE4 #x6EAA) (#xDEE5 #x6E98) (#xDEE6 #x6EC9) (#xDEE7 #x6EB7) (#xDEE8 #x6ED3) (#xDEE9 #x6EBD) (#xDEEA #x6EAF) (#xDEEB #x6EC4) (#xDEEC #x6EB2) (#xDEED #x6ED4) (#xDEEE #x6ED5) (#xDEEF #x6E8F) (#xDEF0 #x6EA5) (#xDEF1 #x6EC2) (#xDEF2 #x6E9F) (#xDEF3 #x6F41) (#xDEF4 #x6F11) (#xDEF5 #x704C) (#xDEF6 #x6EEC) (#xDEF7 #x6EF8) (#xDEF8 #x6EFE) (#xDEF9 #x6F3F) (#xDEFA #x6EF2) (#xDEFB #x6F31) (#xDEFC #x6EEF) (#xDEFD #x6F32) (#xDEFE #x6ECC) (#xDFA1 #x6F3E) (#xDFA2 #x6F13) (#xDFA3 #x6EF7) (#xDFA4 #x6F86) (#xDFA5 #x6F7A) (#xDFA6 #x6F78) (#xDFA7 #x6F81) (#xDFA8 #x6F80) (#xDFA9 #x6F6F) (#xDFAA #x6F5B) (#xDFAB #x6FF3) (#xDFAC #x6F6D) (#xDFAD #x6F82) (#xDFAE #x6F7C) (#xDFAF #x6F58) (#xDFB0 #x6F8E) (#xDFB1 #x6F91) (#xDFB2 #x6FC2) (#xDFB3 #x6F66) (#xDFB4 #x6FB3) (#xDFB5 #x6FA3) (#xDFB6 #x6FA1) (#xDFB7 #x6FA4) (#xDFB8 #x6FB9) (#xDFB9 #x6FC6) (#xDFBA #x6FAA) (#xDFBB #x6FDF) (#xDFBC #x6FD5) (#xDFBD #x6FEC) (#xDFBE #x6FD4) (#xDFBF #x6FD8) (#xDFC0 #x6FF1) (#xDFC1 #x6FEE) (#xDFC2 #x6FDB) (#xDFC3 #x7009) (#xDFC4 #x700B) (#xDFC5 #x6FFA) (#xDFC6 #x7011) (#xDFC7 #x7001) (#xDFC8 #x700F) (#xDFC9 #x6FFE) (#xDFCA #x701B) (#xDFCB #x701A) (#xDFCC #x6F74) (#xDFCD #x701D) (#xDFCE #x7018) (#xDFCF #x701F) (#xDFD0 #x7030) (#xDFD1 #x703E) (#xDFD2 #x7032) (#xDFD3 #x7051) (#xDFD4 #x7063) (#xDFD5 #x7099) (#xDFD6 #x7092) (#xDFD7 #x70AF) (#xDFD8 #x70F1) (#xDFD9 #x70AC) (#xDFDA #x70B8) (#xDFDB #x70B3) (#xDFDC #x70AE) (#xDFDD #x70DF) (#xDFDE #x70CB) (#xDFDF #x70DD) (#xDFE0 #x70D9) (#xDFE1 #x7109) (#xDFE2 #x70FD) (#xDFE3 #x711C) (#xDFE4 #x7119) (#xDFE5 #x7165) (#xDFE6 #x7155) (#xDFE7 #x7188) (#xDFE8 #x7166) (#xDFE9 #x7162) (#xDFEA #x714C) (#xDFEB #x7156) (#xDFEC #x716C) (#xDFED #x718F) (#xDFEE #x71FB) (#xDFEF #x7184) (#xDFF0 #x7195) (#xDFF1 #x71A8) (#xDFF2 #x71AC) (#xDFF3 #x71D7) (#xDFF4 #x71B9) (#xDFF5 #x71BE) (#xDFF6 #x71D2) (#xDFF7 #x71C9) (#xDFF8 #x71D4) (#xDFF9 #x71CE) (#xDFFA #x71E0) (#xDFFB #x71EC) (#xDFFC #x71E7) (#xDFFD #x71F5) (#xDFFE #x71FC) (#xE0A1 #x71F9) (#xE0A2 #x71FF) (#xE0A3 #x720D) (#xE0A4 #x7210) (#xE0A5 #x721B) (#xE0A6 #x7228) (#xE0A7 #x722D) (#xE0A8 #x722C) (#xE0A9 #x7230) (#xE0AA #x7232) (#xE0AB #x723B) (#xE0AC #x723C) (#xE0AD #x723F) (#xE0AE #x7240) (#xE0AF #x7246) (#xE0B0 #x724B) (#xE0B1 #x7258) (#xE0B2 #x7274) (#xE0B3 #x727E) (#xE0B4 #x7282) (#xE0B5 #x7281) (#xE0B6 #x7287) (#xE0B7 #x7292) (#xE0B8 #x7296) (#xE0B9 #x72A2) (#xE0BA #x72A7) (#xE0BB #x72B9) (#xE0BC #x72B2) (#xE0BD #x72C3) (#xE0BE #x72C6) (#xE0BF #x72C4) (#xE0C0 #x72CE) (#xE0C1 #x72D2) (#xE0C2 #x72E2) (#xE0C3 #x72E0) (#xE0C4 #x72E1) (#xE0C5 #x72F9) (#xE0C6 #x72F7) (#xE0C7 #x500F) (#xE0C8 #x7317) (#xE0C9 #x730A) (#xE0CA #x731C) (#xE0CB #x7316) (#xE0CC #x731D) (#xE0CD #x7334) (#xE0CE #x732F) (#xE0CF #x7329) (#xE0D0 #x7325) (#xE0D1 #x733E) (#xE0D2 #x734E) (#xE0D3 #x734F) (#xE0D4 #x9ED8) (#xE0D5 #x7357) (#xE0D6 #x736A) (#xE0D7 #x7368) (#xE0D8 #x7370) (#xE0D9 #x7378) (#xE0DA #x7375) (#xE0DB #x737B) (#xE0DC #x737A) (#xE0DD #x73C8) (#xE0DE #x73B3) (#xE0DF #x73CE) (#xE0E0 #x73BB) (#xE0E1 #x73C0) (#xE0E2 #x73E5) (#xE0E3 #x73EE) (#xE0E4 #x73DE) (#xE0E5 #x74A2) (#xE0E6 #x7405) (#xE0E7 #x746F) (#xE0E8 #x7425) (#xE0E9 #x73F8) (#xE0EA #x7432) (#xE0EB #x743A) (#xE0EC #x7455) (#xE0ED #x743F) (#xE0EE #x745F) (#xE0EF #x7459) (#xE0F0 #x7441) (#xE0F1 #x745C) (#xE0F2 #x7469) (#xE0F3 #x7470) (#xE0F4 #x7463) (#xE0F5 #x746A) (#xE0F6 #x7476) (#xE0F7 #x747E) (#xE0F8 #x748B) (#xE0F9 #x749E) (#xE0FA #x74A7) (#xE0FB #x74CA) (#xE0FC #x74CF) (#xE0FD #x74D4) (#xE0FE #x73F1) (#xE1A1 #x74E0) (#xE1A2 #x74E3) (#xE1A3 #x74E7) (#xE1A4 #x74E9) (#xE1A5 #x74EE) (#xE1A6 #x74F2) (#xE1A7 #x74F0) (#xE1A8 #x74F1) (#xE1A9 #x74F8) (#xE1AA #x74F7) (#xE1AB #x7504) (#xE1AC #x7503) (#xE1AD #x7505) (#xE1AE #x750C) (#xE1AF #x750E) (#xE1B0 #x750D) (#xE1B1 #x7515) (#xE1B2 #x7513) (#xE1B3 #x751E) (#xE1B4 #x7526) (#xE1B5 #x752C) (#xE1B6 #x753C) (#xE1B7 #x7544) (#xE1B8 #x754D) (#xE1B9 #x754A) (#xE1BA #x7549) (#xE1BB #x755B) (#xE1BC #x7546) (#xE1BD #x755A) (#xE1BE #x7569) (#xE1BF #x7564) (#xE1C0 #x7567) (#xE1C1 #x756B) (#xE1C2 #x756D) (#xE1C3 #x7578) (#xE1C4 #x7576) (#xE1C5 #x7586) (#xE1C6 #x7587) (#xE1C7 #x7574) (#xE1C8 #x758A) (#xE1C9 #x7589) (#xE1CA #x7582) (#xE1CB #x7594) (#xE1CC #x759A) (#xE1CD #x759D) (#xE1CE #x75A5) (#xE1CF #x75A3) (#xE1D0 #x75C2) (#xE1D1 #x75B3) (#xE1D2 #x75C3) (#xE1D3 #x75B5) (#xE1D4 #x75BD) (#xE1D5 #x75B8) (#xE1D6 #x75BC) (#xE1D7 #x75B1) (#xE1D8 #x75CD) (#xE1D9 #x75CA) (#xE1DA #x75D2) (#xE1DB #x75D9) (#xE1DC #x75E3) (#xE1DD #x75DE) (#xE1DE #x75FE) (#xE1DF #x75FF) (#xE1E0 #x75FC) (#xE1E1 #x7601) (#xE1E2 #x75F0) (#xE1E3 #x75FA) (#xE1E4 #x75F2) (#xE1E5 #x75F3) (#xE1E6 #x760B) (#xE1E7 #x760D) (#xE1E8 #x7609) (#xE1E9 #x761F) (#xE1EA #x7627) (#xE1EB #x7620) (#xE1EC #x7621) (#xE1ED #x7622) (#xE1EE #x7624) (#xE1EF #x7634) (#xE1F0 #x7630) (#xE1F1 #x763B) (#xE1F2 #x7647) (#xE1F3 #x7648) (#xE1F4 #x7646) (#xE1F5 #x765C) (#xE1F6 #x7658) (#xE1F7 #x7661) (#xE1F8 #x7662) (#xE1F9 #x7668) (#xE1FA #x7669) (#xE1FB #x766A) (#xE1FC #x7667) (#xE1FD #x766C) (#xE1FE #x7670) (#xE2A1 #x7672) (#xE2A2 #x7676) (#xE2A3 #x7678) (#xE2A4 #x767C) (#xE2A5 #x7680) (#xE2A6 #x7683) (#xE2A7 #x7688) (#xE2A8 #x768B) (#xE2A9 #x768E) (#xE2AA #x7696) (#xE2AB #x7693) (#xE2AC #x7699) (#xE2AD #x769A) (#xE2AE #x76B0) (#xE2AF #x76B4) (#xE2B0 #x76B8) (#xE2B1 #x76B9) (#xE2B2 #x76BA) (#xE2B3 #x76C2) (#xE2B4 #x76CD) (#xE2B5 #x76D6) (#xE2B6 #x76D2) (#xE2B7 #x76DE) (#xE2B8 #x76E1) (#xE2B9 #x76E5) (#xE2BA #x76E7) (#xE2BB #x76EA) (#xE2BC #x862F) (#xE2BD #x76FB) (#xE2BE #x7708) (#xE2BF #x7707) (#xE2C0 #x7704) (#xE2C1 #x7729) (#xE2C2 #x7724) (#xE2C3 #x771E) (#xE2C4 #x7725) (#xE2C5 #x7726) (#xE2C6 #x771B) (#xE2C7 #x7737) (#xE2C8 #x7738) (#xE2C9 #x7747) (#xE2CA #x775A) (#xE2CB #x7768) (#xE2CC #x776B) (#xE2CD #x775B) (#xE2CE #x7765) (#xE2CF #x777F) (#xE2D0 #x777E) (#xE2D1 #x7779) (#xE2D2 #x778E) (#xE2D3 #x778B) (#xE2D4 #x7791) (#xE2D5 #x77A0) (#xE2D6 #x779E) (#xE2D7 #x77B0) (#xE2D8 #x77B6) (#xE2D9 #x77B9) (#xE2DA #x77BF) (#xE2DB #x77BC) (#xE2DC #x77BD) (#xE2DD #x77BB) (#xE2DE #x77C7) (#xE2DF #x77CD) (#xE2E0 #x77D7) (#xE2E1 #x77DA) (#xE2E2 #x77DC) (#xE2E3 #x77E3) (#xE2E4 #x77EE) (#xE2E5 #x77FC) (#xE2E6 #x780C) (#xE2E7 #x7812) (#xE2E8 #x7926) (#xE2E9 #x7820) (#xE2EA #x792A) (#xE2EB #x7845) (#xE2EC #x788E) (#xE2ED #x7874) (#xE2EE #x7886) (#xE2EF #x787C) (#xE2F0 #x789A) (#xE2F1 #x788C) (#xE2F2 #x78A3) (#xE2F3 #x78B5) (#xE2F4 #x78AA) (#xE2F5 #x78AF) (#xE2F6 #x78D1) (#xE2F7 #x78C6) (#xE2F8 #x78CB) (#xE2F9 #x78D4) (#xE2FA #x78BE) (#xE2FB #x78BC) (#xE2FC #x78C5) (#xE2FD #x78CA) (#xE2FE #x78EC) (#xE3A1 #x78E7) (#xE3A2 #x78DA) (#xE3A3 #x78FD) (#xE3A4 #x78F4) (#xE3A5 #x7907) (#xE3A6 #x7912) (#xE3A7 #x7911) (#xE3A8 #x7919) (#xE3A9 #x792C) (#xE3AA #x792B) (#xE3AB #x7940) (#xE3AC #x7960) (#xE3AD #x7957) (#xE3AE #x795F) (#xE3AF #x795A) (#xE3B0 #x7955) (#xE3B1 #x7953) (#xE3B2 #x797A) (#xE3B3 #x797F) (#xE3B4 #x798A) (#xE3B5 #x799D) (#xE3B6 #x79A7) (#xE3B7 #x9F4B) (#xE3B8 #x79AA) (#xE3B9 #x79AE) (#xE3BA #x79B3) (#xE3BB #x79B9) (#xE3BC #x79BA) (#xE3BD #x79C9) (#xE3BE #x79D5) (#xE3BF #x79E7) (#xE3C0 #x79EC) (#xE3C1 #x79E1) (#xE3C2 #x79E3) (#xE3C3 #x7A08) (#xE3C4 #x7A0D) (#xE3C5 #x7A18) (#xE3C6 #x7A19) (#xE3C7 #x7A20) (#xE3C8 #x7A1F) (#xE3C9 #x7980) (#xE3CA #x7A31) (#xE3CB #x7A3B) (#xE3CC #x7A3E) (#xE3CD #x7A37) (#xE3CE #x7A43) (#xE3CF #x7A57) (#xE3D0 #x7A49) (#xE3D1 #x7A61) (#xE3D2 #x7A62) (#xE3D3 #x7A69) (#xE3D4 #x9F9D) (#xE3D5 #x7A70) (#xE3D6 #x7A79) (#xE3D7 #x7A7D) (#xE3D8 #x7A88) (#xE3D9 #x7A97) (#xE3DA #x7A95) (#xE3DB #x7A98) (#xE3DC #x7A96) (#xE3DD #x7AA9) (#xE3DE #x7AC8) (#xE3DF #x7AB0) (#xE3E0 #x7AB6) (#xE3E1 #x7AC5) (#xE3E2 #x7AC4) (#xE3E3 #x7ABF) (#xE3E4 #x9083) (#xE3E5 #x7AC7) (#xE3E6 #x7ACA) (#xE3E7 #x7ACD) (#xE3E8 #x7ACF) (#xE3E9 #x7AD5) (#xE3EA #x7AD3) (#xE3EB #x7AD9) (#xE3EC #x7ADA) (#xE3ED #x7ADD) (#xE3EE #x7AE1) (#xE3EF #x7AE2) (#xE3F0 #x7AE6) (#xE3F1 #x7AED) (#xE3F2 #x7AF0) (#xE3F3 #x7B02) (#xE3F4 #x7B0F) (#xE3F5 #x7B0A) (#xE3F6 #x7B06) (#xE3F7 #x7B33) (#xE3F8 #x7B18) (#xE3F9 #x7B19) (#xE3FA #x7B1E) (#xE3FB #x7B35) (#xE3FC #x7B28) (#xE3FD #x7B36) (#xE3FE #x7B50) (#xE4A1 #x7B7A) (#xE4A2 #x7B04) (#xE4A3 #x7B4D) (#xE4A4 #x7B0B) (#xE4A5 #x7B4C) (#xE4A6 #x7B45) (#xE4A7 #x7B75) (#xE4A8 #x7B65) (#xE4A9 #x7B74) (#xE4AA #x7B67) (#xE4AB #x7B70) (#xE4AC #x7B71) (#xE4AD #x7B6C) (#xE4AE #x7B6E) (#xE4AF #x7B9D) (#xE4B0 #x7B98) (#xE4B1 #x7B9F) (#xE4B2 #x7B8D) (#xE4B3 #x7B9C) (#xE4B4 #x7B9A) (#xE4B5 #x7B8B) (#xE4B6 #x7B92) (#xE4B7 #x7B8F) (#xE4B8 #x7B5D) (#xE4B9 #x7B99) (#xE4BA #x7BCB) (#xE4BB #x7BC1) (#xE4BC #x7BCC) (#xE4BD #x7BCF) (#xE4BE #x7BB4) (#xE4BF #x7BC6) (#xE4C0 #x7BDD) (#xE4C1 #x7BE9) (#xE4C2 #x7C11) (#xE4C3 #x7C14) (#xE4C4 #x7BE6) (#xE4C5 #x7BE5) (#xE4C6 #x7C60) (#xE4C7 #x7C00) (#xE4C8 #x7C07) (#xE4C9 #x7C13) (#xE4CA #x7BF3) (#xE4CB #x7BF7) (#xE4CC #x7C17) (#xE4CD #x7C0D) (#xE4CE #x7BF6) (#xE4CF #x7C23) (#xE4D0 #x7C27) (#xE4D1 #x7C2A) (#xE4D2 #x7C1F) (#xE4D3 #x7C37) (#xE4D4 #x7C2B) (#xE4D5 #x7C3D) (#xE4D6 #x7C4C) (#xE4D7 #x7C43) (#xE4D8 #x7C54) (#xE4D9 #x7C4F) (#xE4DA #x7C40) (#xE4DB #x7C50) (#xE4DC #x7C58) (#xE4DD #x7C5F) (#xE4DE #x7C64) (#xE4DF #x7C56) (#xE4E0 #x7C65) (#xE4E1 #x7C6C) (#xE4E2 #x7C75) (#xE4E3 #x7C83) (#xE4E4 #x7C90) (#xE4E5 #x7CA4) (#xE4E6 #x7CAD) (#xE4E7 #x7CA2) (#xE4E8 #x7CAB) (#xE4E9 #x7CA1) (#xE4EA #x7CA8) (#xE4EB #x7CB3) (#xE4EC #x7CB2) (#xE4ED #x7CB1) (#xE4EE #x7CAE) (#xE4EF #x7CB9) (#xE4F0 #x7CBD) (#xE4F1 #x7CC0) (#xE4F2 #x7CC5) (#xE4F3 #x7CC2) (#xE4F4 #x7CD8) (#xE4F5 #x7CD2) (#xE4F6 #x7CDC) (#xE4F7 #x7CE2) (#xE4F8 #x9B3B) (#xE4F9 #x7CEF) (#xE4FA #x7CF2) (#xE4FB #x7CF4) (#xE4FC #x7CF6) (#xE4FD #x7CFA) (#xE4FE #x7D06) (#xE5A1 #x7D02) (#xE5A2 #x7D1C) (#xE5A3 #x7D15) (#xE5A4 #x7D0A) (#xE5A5 #x7D45) (#xE5A6 #x7D4B) (#xE5A7 #x7D2E) (#xE5A8 #x7D32) (#xE5A9 #x7D3F) (#xE5AA #x7D35) (#xE5AB #x7D46) (#xE5AC #x7D73) (#xE5AD #x7D56) (#xE5AE #x7D4E) (#xE5AF #x7D72) (#xE5B0 #x7D68) (#xE5B1 #x7D6E) (#xE5B2 #x7D4F) (#xE5B3 #x7D63) (#xE5B4 #x7D93) (#xE5B5 #x7D89) (#xE5B6 #x7D5B) (#xE5B7 #x7D8F) (#xE5B8 #x7D7D) (#xE5B9 #x7D9B) (#xE5BA #x7DBA) (#xE5BB #x7DAE) (#xE5BC #x7DA3) (#xE5BD #x7DB5) (#xE5BE #x7DC7) (#xE5BF #x7DBD) (#xE5C0 #x7DAB) (#xE5C1 #x7E3D) (#xE5C2 #x7DA2) (#xE5C3 #x7DAF) (#xE5C4 #x7DDC) (#xE5C5 #x7DB8) (#xE5C6 #x7D9F) (#xE5C7 #x7DB0) (#xE5C8 #x7DD8) (#xE5C9 #x7DDD) (#xE5CA #x7DE4) (#xE5CB #x7DDE) (#xE5CC #x7DFB) (#xE5CD #x7DF2) (#xE5CE #x7DE1) (#xE5CF #x7E05) (#xE5D0 #x7E0A) (#xE5D1 #x7E23) (#xE5D2 #x7E21) (#xE5D3 #x7E12) (#xE5D4 #x7E31) (#xE5D5 #x7E1F) (#xE5D6 #x7E09) (#xE5D7 #x7E0B) (#xE5D8 #x7E22) (#xE5D9 #x7E46) (#xE5DA #x7E66) (#xE5DB #x7E3B) (#xE5DC #x7E35) (#xE5DD #x7E39) (#xE5DE #x7E43) (#xE5DF #x7E37) (#xE5E0 #x7E32) (#xE5E1 #x7E3A) (#xE5E2 #x7E67) (#xE5E3 #x7E5D) (#xE5E4 #x7E56) (#xE5E5 #x7E5E) (#xE5E6 #x7E59) (#xE5E7 #x7E5A) (#xE5E8 #x7E79) (#xE5E9 #x7E6A) (#xE5EA #x7E69) (#xE5EB #x7E7C) (#xE5EC #x7E7B) (#xE5ED #x7E83) (#xE5EE #x7DD5) (#xE5EF #x7E7D) (#xE5F0 #x8FAE) (#xE5F1 #x7E7F) (#xE5F2 #x7E88) (#xE5F3 #x7E89) (#xE5F4 #x7E8C) (#xE5F5 #x7E92) (#xE5F6 #x7E90) (#xE5F7 #x7E93) (#xE5F8 #x7E94) (#xE5F9 #x7E96) (#xE5FA #x7E8E) (#xE5FB #x7E9B) (#xE5FC #x7E9C) (#xE5FD #x7F38) (#xE5FE #x7F3A) (#xE6A1 #x7F45) (#xE6A2 #x7F4C) (#xE6A3 #x7F4D) (#xE6A4 #x7F4E) (#xE6A5 #x7F50) (#xE6A6 #x7F51) (#xE6A7 #x7F55) (#xE6A8 #x7F54) (#xE6A9 #x7F58) (#xE6AA #x7F5F) (#xE6AB #x7F60) (#xE6AC #x7F68) (#xE6AD #x7F69) (#xE6AE #x7F67) (#xE6AF #x7F78) (#xE6B0 #x7F82) (#xE6B1 #x7F86) (#xE6B2 #x7F83) (#xE6B3 #x7F88) (#xE6B4 #x7F87) (#xE6B5 #x7F8C) (#xE6B6 #x7F94) (#xE6B7 #x7F9E) (#xE6B8 #x7F9D) (#xE6B9 #x7F9A) (#xE6BA #x7FA3) (#xE6BB #x7FAF) (#xE6BC #x7FB2) (#xE6BD #x7FB9) (#xE6BE #x7FAE) (#xE6BF #x7FB6) (#xE6C0 #x7FB8) (#xE6C1 #x8B71) (#xE6C2 #x7FC5) (#xE6C3 #x7FC6) (#xE6C4 #x7FCA) (#xE6C5 #x7FD5) (#xE6C6 #x7FD4) (#xE6C7 #x7FE1) (#xE6C8 #x7FE6) (#xE6C9 #x7FE9) (#xE6CA #x7FF3) (#xE6CB #x7FF9) (#xE6CC #x98DC) (#xE6CD #x8006) (#xE6CE #x8004) (#xE6CF #x800B) (#xE6D0 #x8012) (#xE6D1 #x8018) (#xE6D2 #x8019) (#xE6D3 #x801C) (#xE6D4 #x8021) (#xE6D5 #x8028) (#xE6D6 #x803F) (#xE6D7 #x803B) (#xE6D8 #x804A) (#xE6D9 #x8046) (#xE6DA #x8052) (#xE6DB #x8058) (#xE6DC #x805A) (#xE6DD #x805F) (#xE6DE #x8062) (#xE6DF #x8068) (#xE6E0 #x8073) (#xE6E1 #x8072) (#xE6E2 #x8070) (#xE6E3 #x8076) (#xE6E4 #x8079) (#xE6E5 #x807D) (#xE6E6 #x807F) (#xE6E7 #x8084) (#xE6E8 #x8086) (#xE6E9 #x8085) (#xE6EA #x809B) (#xE6EB #x8093) (#xE6EC #x809A) (#xE6ED #x80AD) (#xE6EE #x5190) (#xE6EF #x80AC) (#xE6F0 #x80DB) (#xE6F1 #x80E5) (#xE6F2 #x80D9) (#xE6F3 #x80DD) (#xE6F4 #x80C4) (#xE6F5 #x80DA) (#xE6F6 #x80D6) (#xE6F7 #x8109) (#xE6F8 #x80EF) (#xE6F9 #x80F1) (#xE6FA #x811B) (#xE6FB #x8129) (#xE6FC #x8123) (#xE6FD #x812F) (#xE6FE #x814B) (#xE7A1 #x968B) (#xE7A2 #x8146) (#xE7A3 #x813E) (#xE7A4 #x8153) (#xE7A5 #x8151) (#xE7A6 #x80FC) (#xE7A7 #x8171) (#xE7A8 #x816E) (#xE7A9 #x8165) (#xE7AA #x8166) (#xE7AB #x8174) (#xE7AC #x8183) (#xE7AD #x8188) (#xE7AE #x818A) (#xE7AF #x8180) (#xE7B0 #x8182) (#xE7B1 #x81A0) (#xE7B2 #x8195) (#xE7B3 #x81A4) (#xE7B4 #x81A3) (#xE7B5 #x815F) (#xE7B6 #x8193) (#xE7B7 #x81A9) (#xE7B8 #x81B0) (#xE7B9 #x81B5) (#xE7BA #x81BE) (#xE7BB #x81B8) (#xE7BC #x81BD) (#xE7BD #x81C0) (#xE7BE #x81C2) (#xE7BF #x81BA) (#xE7C0 #x81C9) (#xE7C1 #x81CD) (#xE7C2 #x81D1) (#xE7C3 #x81D9) (#xE7C4 #x81D8) (#xE7C5 #x81C8) (#xE7C6 #x81DA) (#xE7C7 #x81DF) (#xE7C8 #x81E0) (#xE7C9 #x81E7) (#xE7CA #x81FA) (#xE7CB #x81FB) (#xE7CC #x81FE) (#xE7CD #x8201) (#xE7CE #x8202) (#xE7CF #x8205) (#xE7D0 #x8207) (#xE7D1 #x820A) (#xE7D2 #x820D) (#xE7D3 #x8210) (#xE7D4 #x8216) (#xE7D5 #x8229) (#xE7D6 #x822B) (#xE7D7 #x8238) (#xE7D8 #x8233) (#xE7D9 #x8240) (#xE7DA #x8259) (#xE7DB #x8258) (#xE7DC #x825D) (#xE7DD #x825A) (#xE7DE #x825F) (#xE7DF #x8264) (#xE7E0 #x8262) (#xE7E1 #x8268) (#xE7E2 #x826A) (#xE7E3 #x826B) (#xE7E4 #x822E) (#xE7E5 #x8271) (#xE7E6 #x8277) (#xE7E7 #x8278) (#xE7E8 #x827E) (#xE7E9 #x828D) (#xE7EA #x8292) (#xE7EB #x82AB) (#xE7EC #x829F) (#xE7ED #x82BB) (#xE7EE #x82AC) (#xE7EF #x82E1) (#xE7F0 #x82E3) (#xE7F1 #x82DF) (#xE7F2 #x82D2) (#xE7F3 #x82F4) (#xE7F4 #x82F3) (#xE7F5 #x82FA) (#xE7F6 #x8393) (#xE7F7 #x8303) (#xE7F8 #x82FB) (#xE7F9 #x82F9) (#xE7FA #x82DE) (#xE7FB #x8306) (#xE7FC #x82DC) (#xE7FD #x8309) (#xE7FE #x82D9) (#xE8A1 #x8335) (#xE8A2 #x8334) (#xE8A3 #x8316) (#xE8A4 #x8332) (#xE8A5 #x8331) (#xE8A6 #x8340) (#xE8A7 #x8339) (#xE8A8 #x8350) (#xE8A9 #x8345) (#xE8AA #x832F) (#xE8AB #x832B) (#xE8AC #x8317) (#xE8AD #x8318) (#xE8AE #x8385) (#xE8AF #x839A) (#xE8B0 #x83AA) (#xE8B1 #x839F) (#xE8B2 #x83A2) (#xE8B3 #x8396) (#xE8B4 #x8323) (#xE8B5 #x838E) (#xE8B6 #x8387) (#xE8B7 #x838A) (#xE8B8 #x837C) (#xE8B9 #x83B5) (#xE8BA #x8373) (#xE8BB #x8375) (#xE8BC #x83A0) (#xE8BD #x8389) (#xE8BE #x83A8) (#xE8BF #x83F4) (#xE8C0 #x8413) (#xE8C1 #x83EB) (#xE8C2 #x83CE) (#xE8C3 #x83FD) (#xE8C4 #x8403) (#xE8C5 #x83D8) (#xE8C6 #x840B) (#xE8C7 #x83C1) (#xE8C8 #x83F7) (#xE8C9 #x8407) (#xE8CA #x83E0) (#xE8CB #x83F2) (#xE8CC #x840D) (#xE8CD #x8422) (#xE8CE #x8420) (#xE8CF #x83BD) (#xE8D0 #x8438) (#xE8D1 #x8506) (#xE8D2 #x83FB) (#xE8D3 #x846D) (#xE8D4 #x842A) (#xE8D5 #x843C) (#xE8D6 #x855A) (#xE8D7 #x8484) (#xE8D8 #x8477) (#xE8D9 #x846B) (#xE8DA #x84AD) (#xE8DB #x846E) (#xE8DC #x8482) (#xE8DD #x8469) (#xE8DE #x8446) (#xE8DF #x842C) (#xE8E0 #x846F) (#xE8E1 #x8479) (#xE8E2 #x8435) (#xE8E3 #x84CA) (#xE8E4 #x8462) (#xE8E5 #x84B9) (#xE8E6 #x84BF) (#xE8E7 #x849F) (#xE8E8 #x84D9) (#xE8E9 #x84CD) (#xE8EA #x84BB) (#xE8EB #x84DA) (#xE8EC #x84D0) (#xE8ED #x84C1) (#xE8EE #x84C6) (#xE8EF #x84D6) (#xE8F0 #x84A1) (#xE8F1 #x8521) (#xE8F2 #x84FF) (#xE8F3 #x84F4) (#xE8F4 #x8517) (#xE8F5 #x8518) (#xE8F6 #x852C) (#xE8F7 #x851F) (#xE8F8 #x8515) (#xE8F9 #x8514) (#xE8FA #x84FC) (#xE8FB #x8540) (#xE8FC #x8563) (#xE8FD #x8558) (#xE8FE #x8548) (#xE9A1 #x8541) (#xE9A2 #x8602) (#xE9A3 #x854B) (#xE9A4 #x8555) (#xE9A5 #x8580) (#xE9A6 #x85A4) (#xE9A7 #x8588) (#xE9A8 #x8591) (#xE9A9 #x858A) (#xE9AA #x85A8) (#xE9AB #x856D) (#xE9AC #x8594) (#xE9AD #x859B) (#xE9AE #x85EA) (#xE9AF #x8587) (#xE9B0 #x859C) (#xE9B1 #x8577) (#xE9B2 #x857E) (#xE9B3 #x8590) (#xE9B4 #x85C9) (#xE9B5 #x85BA) (#xE9B6 #x85CF) (#xE9B7 #x85B9) (#xE9B8 #x85D0) (#xE9B9 #x85D5) (#xE9BA #x85DD) (#xE9BB #x85E5) (#xE9BC #x85DC) (#xE9BD #x85F9) (#xE9BE #x860A) (#xE9BF #x8613) (#xE9C0 #x860B) (#xE9C1 #x85FE) (#xE9C2 #x85FA) (#xE9C3 #x8606) (#xE9C4 #x8622) (#xE9C5 #x861A) (#xE9C6 #x8630) (#xE9C7 #x863F) (#xE9C8 #x864D) (#xE9C9 #x4E55) (#xE9CA #x8654) (#xE9CB #x865F) (#xE9CC #x8667) (#xE9CD #x8671) (#xE9CE #x8693) (#xE9CF #x86A3) (#xE9D0 #x86A9) (#xE9D1 #x86AA) (#xE9D2 #x868B) (#xE9D3 #x868C) (#xE9D4 #x86B6) (#xE9D5 #x86AF) (#xE9D6 #x86C4) (#xE9D7 #x86C6) (#xE9D8 #x86B0) (#xE9D9 #x86C9) (#xE9DA #x8823) (#xE9DB #x86AB) (#xE9DC #x86D4) (#xE9DD #x86DE) (#xE9DE #x86E9) (#xE9DF #x86EC) (#xE9E0 #x86DF) (#xE9E1 #x86DB) (#xE9E2 #x86EF) (#xE9E3 #x8712) (#xE9E4 #x8706) (#xE9E5 #x8708) (#xE9E6 #x8700) (#xE9E7 #x8703) (#xE9E8 #x86FB) (#xE9E9 #x8711) (#xE9EA #x8709) (#xE9EB #x870D) (#xE9EC #x86F9) (#xE9ED #x870A) (#xE9EE #x8734) (#xE9EF #x873F) (#xE9F0 #x8737) (#xE9F1 #x873B) (#xE9F2 #x8725) (#xE9F3 #x8729) (#xE9F4 #x871A) (#xE9F5 #x8760) (#xE9F6 #x875F) (#xE9F7 #x8778) (#xE9F8 #x874C) (#xE9F9 #x874E) (#xE9FA #x8774) (#xE9FB #x8757) (#xE9FC #x8768) (#xE9FD #x876E) (#xE9FE #x8759) (#xEAA1 #x8753) (#xEAA2 #x8763) (#xEAA3 #x876A) (#xEAA4 #x8805) (#xEAA5 #x87A2) (#xEAA6 #x879F) (#xEAA7 #x8782) (#xEAA8 #x87AF) (#xEAA9 #x87CB) (#xEAAA #x87BD) (#xEAAB #x87C0) (#xEAAC #x87D0) (#xEAAD #x96D6) (#xEAAE #x87AB) (#xEAAF #x87C4) (#xEAB0 #x87B3) (#xEAB1 #x87C7) (#xEAB2 #x87C6) (#xEAB3 #x87BB) (#xEAB4 #x87EF) (#xEAB5 #x87F2) (#xEAB6 #x87E0) (#xEAB7 #x880F) (#xEAB8 #x880D) (#xEAB9 #x87FE) (#xEABA #x87F6) (#xEABB #x87F7) (#xEABC #x880E) (#xEABD #x87D2) (#xEABE #x8811) (#xEABF #x8816) (#xEAC0 #x8815) (#xEAC1 #x8822) (#xEAC2 #x8821) (#xEAC3 #x8831) (#xEAC4 #x8836) (#xEAC5 #x8839) (#xEAC6 #x8827) (#xEAC7 #x883B) (#xEAC8 #x8844) (#xEAC9 #x8842) (#xEACA #x8852) (#xEACB #x8859) (#xEACC #x885E) (#xEACD #x8862) (#xEACE #x886B) (#xEACF #x8881) (#xEAD0 #x887E) (#xEAD1 #x889E) (#xEAD2 #x8875) (#xEAD3 #x887D) (#xEAD4 #x88B5) (#xEAD5 #x8872) (#xEAD6 #x8882) (#xEAD7 #x8897) (#xEAD8 #x8892) (#xEAD9 #x88AE) (#xEADA #x8899) (#xEADB #x88A2) (#xEADC #x888D) (#xEADD #x88A4) (#xEADE #x88B0) (#xEADF #x88BF) (#xEAE0 #x88B1) (#xEAE1 #x88C3) (#xEAE2 #x88C4) (#xEAE3 #x88D4) (#xEAE4 #x88D8) (#xEAE5 #x88D9) (#xEAE6 #x88DD) (#xEAE7 #x88F9) (#xEAE8 #x8902) (#xEAE9 #x88FC) (#xEAEA #x88F4) (#xEAEB #x88E8) (#xEAEC #x88F2) (#xEAED #x8904) (#xEAEE #x890C) (#xEAEF #x890A) (#xEAF0 #x8913) (#xEAF1 #x8943) (#xEAF2 #x891E) (#xEAF3 #x8925) (#xEAF4 #x892A) (#xEAF5 #x892B) (#xEAF6 #x8941) (#xEAF7 #x8944) (#xEAF8 #x893B) (#xEAF9 #x8936) (#xEAFA #x8938) (#xEAFB #x894C) (#xEAFC #x891D) (#xEAFD #x8960) (#xEAFE #x895E) (#xEBA1 #x8966) (#xEBA2 #x8964) (#xEBA3 #x896D) (#xEBA4 #x896A) (#xEBA5 #x896F) (#xEBA6 #x8974) (#xEBA7 #x8977) (#xEBA8 #x897E) (#xEBA9 #x8983) (#xEBAA #x8988) (#xEBAB #x898A) (#xEBAC #x8993) (#xEBAD #x8998) (#xEBAE #x89A1) (#xEBAF #x89A9) (#xEBB0 #x89A6) (#xEBB1 #x89AC) (#xEBB2 #x89AF) (#xEBB3 #x89B2) (#xEBB4 #x89BA) (#xEBB5 #x89BD) (#xEBB6 #x89BF) (#xEBB7 #x89C0) (#xEBB8 #x89DA) (#xEBB9 #x89DC) (#xEBBA #x89DD) (#xEBBB #x89E7) (#xEBBC #x89F4) (#xEBBD #x89F8) (#xEBBE #x8A03) (#xEBBF #x8A16) (#xEBC0 #x8A10) (#xEBC1 #x8A0C) (#xEBC2 #x8A1B) (#xEBC3 #x8A1D) (#xEBC4 #x8A25) (#xEBC5 #x8A36) (#xEBC6 #x8A41) (#xEBC7 #x8A5B) (#xEBC8 #x8A52) (#xEBC9 #x8A46) (#xEBCA #x8A48) (#xEBCB #x8A7C) (#xEBCC #x8A6D) (#xEBCD #x8A6C) (#xEBCE #x8A62) (#xEBCF #x8A85) (#xEBD0 #x8A82) (#xEBD1 #x8A84) (#xEBD2 #x8AA8) (#xEBD3 #x8AA1) (#xEBD4 #x8A91) (#xEBD5 #x8AA5) (#xEBD6 #x8AA6) (#xEBD7 #x8A9A) (#xEBD8 #x8AA3) (#xEBD9 #x8AC4) (#xEBDA #x8ACD) (#xEBDB #x8AC2) (#xEBDC #x8ADA) (#xEBDD #x8AEB) (#xEBDE #x8AF3) (#xEBDF #x8AE7) (#xEBE0 #x8AE4) (#xEBE1 #x8AF1) (#xEBE2 #x8B14) (#xEBE3 #x8AE0) (#xEBE4 #x8AE2) (#xEBE5 #x8AF7) (#xEBE6 #x8ADE) (#xEBE7 #x8ADB) (#xEBE8 #x8B0C) (#xEBE9 #x8B07) (#xEBEA #x8B1A) (#xEBEB #x8AE1) (#xEBEC #x8B16) (#xEBED #x8B10) (#xEBEE #x8B17) (#xEBEF #x8B20) (#xEBF0 #x8B33) (#xEBF1 #x97AB) (#xEBF2 #x8B26) (#xEBF3 #x8B2B) (#xEBF4 #x8B3E) (#xEBF5 #x8B28) (#xEBF6 #x8B41) (#xEBF7 #x8B4C) (#xEBF8 #x8B4F) (#xEBF9 #x8B4E) (#xEBFA #x8B49) (#xEBFB #x8B56) (#xEBFC #x8B5B) (#xEBFD #x8B5A) (#xEBFE #x8B6B) (#xECA1 #x8B5F) (#xECA2 #x8B6C) (#xECA3 #x8B6F) (#xECA4 #x8B74) (#xECA5 #x8B7D) (#xECA6 #x8B80) (#xECA7 #x8B8C) (#xECA8 #x8B8E) (#xECA9 #x8B92) (#xECAA #x8B93) (#xECAB #x8B96) (#xECAC #x8B99) (#xECAD #x8B9A) (#xECAE #x8C3A) (#xECAF #x8C41) (#xECB0 #x8C3F) (#xECB1 #x8C48) (#xECB2 #x8C4C) (#xECB3 #x8C4E) (#xECB4 #x8C50) (#xECB5 #x8C55) (#xECB6 #x8C62) (#xECB7 #x8C6C) (#xECB8 #x8C78) (#xECB9 #x8C7A) (#xECBA #x8C82) (#xECBB #x8C89) (#xECBC #x8C85) (#xECBD #x8C8A) (#xECBE #x8C8D) (#xECBF #x8C8E) (#xECC0 #x8C94) (#xECC1 #x8C7C) (#xECC2 #x8C98) (#xECC3 #x621D) (#xECC4 #x8CAD) (#xECC5 #x8CAA) (#xECC6 #x8CBD) (#xECC7 #x8CB2) (#xECC8 #x8CB3) (#xECC9 #x8CAE) (#xECCA #x8CB6) (#xECCB #x8CC8) (#xECCC #x8CC1) (#xECCD #x8CE4) (#xECCE #x8CE3) (#xECCF #x8CDA) (#xECD0 #x8CFD) (#xECD1 #x8CFA) (#xECD2 #x8CFB) (#xECD3 #x8D04) (#xECD4 #x8D05) (#xECD5 #x8D0A) (#xECD6 #x8D07) (#xECD7 #x8D0F) (#xECD8 #x8D0D) (#xECD9 #x8D10) (#xECDA #x9F4E) (#xECDB #x8D13) (#xECDC #x8CCD) (#xECDD #x8D14) (#xECDE #x8D16) (#xECDF #x8D67) (#xECE0 #x8D6D) (#xECE1 #x8D71) (#xECE2 #x8D73) (#xECE3 #x8D81) (#xECE4 #x8D99) (#xECE5 #x8DC2) (#xECE6 #x8DBE) (#xECE7 #x8DBA) (#xECE8 #x8DCF) (#xECE9 #x8DDA) (#xECEA #x8DD6) (#xECEB #x8DCC) (#xECEC #x8DDB) (#xECED #x8DCB) (#xECEE #x8DEA) (#xECEF #x8DEB) (#xECF0 #x8DDF) (#xECF1 #x8DE3) (#xECF2 #x8DFC) (#xECF3 #x8E08) (#xECF4 #x8E09) (#xECF5 #x8DFF) (#xECF6 #x8E1D) (#xECF7 #x8E1E) (#xECF8 #x8E10) (#xECF9 #x8E1F) (#xECFA #x8E42) (#xECFB #x8E35) (#xECFC #x8E30) (#xECFD #x8E34) (#xECFE #x8E4A) (#xEDA1 #x8E47) (#xEDA2 #x8E49) (#xEDA3 #x8E4C) (#xEDA4 #x8E50) (#xEDA5 #x8E48) (#xEDA6 #x8E59) (#xEDA7 #x8E64) (#xEDA8 #x8E60) (#xEDA9 #x8E2A) (#xEDAA #x8E63) (#xEDAB #x8E55) (#xEDAC #x8E76) (#xEDAD #x8E72) (#xEDAE #x8E7C) (#xEDAF #x8E81) (#xEDB0 #x8E87) (#xEDB1 #x8E85) (#xEDB2 #x8E84) (#xEDB3 #x8E8B) (#xEDB4 #x8E8A) (#xEDB5 #x8E93) (#xEDB6 #x8E91) (#xEDB7 #x8E94) (#xEDB8 #x8E99) (#xEDB9 #x8EAA) (#xEDBA #x8EA1) (#xEDBB #x8EAC) (#xEDBC #x8EB0) (#xEDBD #x8EC6) (#xEDBE #x8EB1) (#xEDBF #x8EBE) (#xEDC0 #x8EC5) (#xEDC1 #x8EC8) (#xEDC2 #x8ECB) (#xEDC3 #x8EDB) (#xEDC4 #x8EE3) (#xEDC5 #x8EFC) (#xEDC6 #x8EFB) (#xEDC7 #x8EEB) (#xEDC8 #x8EFE) (#xEDC9 #x8F0A) (#xEDCA #x8F05) (#xEDCB #x8F15) (#xEDCC #x8F12) (#xEDCD #x8F19) (#xEDCE #x8F13) (#xEDCF #x8F1C) (#xEDD0 #x8F1F) (#xEDD1 #x8F1B) (#xEDD2 #x8F0C) (#xEDD3 #x8F26) (#xEDD4 #x8F33) (#xEDD5 #x8F3B) (#xEDD6 #x8F39) (#xEDD7 #x8F45) (#xEDD8 #x8F42) (#xEDD9 #x8F3E) (#xEDDA #x8F4C) (#xEDDB #x8F49) (#xEDDC #x8F46) (#xEDDD #x8F4E) (#xEDDE #x8F57) (#xEDDF #x8F5C) (#xEDE0 #x8F62) (#xEDE1 #x8F63) (#xEDE2 #x8F64) (#xEDE3 #x8F9C) (#xEDE4 #x8F9F) (#xEDE5 #x8FA3) (#xEDE6 #x8FAD) (#xEDE7 #x8FAF) (#xEDE8 #x8FB7) (#xEDE9 #x8FDA) (#xEDEA #x8FE5) (#xEDEB #x8FE2) (#xEDEC #x8FEA) (#xEDED #x8FEF) (#xEDEE #x9087) (#xEDEF #x8FF4) (#xEDF0 #x9005) (#xEDF1 #x8FF9) (#xEDF2 #x8FFA) (#xEDF3 #x9011) (#xEDF4 #x9015) (#xEDF5 #x9021) (#xEDF6 #x900D) (#xEDF7 #x901E) (#xEDF8 #x9016) (#xEDF9 #x900B) (#xEDFA #x9027) (#xEDFB #x9036) (#xEDFC #x9035) (#xEDFD #x9039) (#xEDFE #x8FF8) (#xEEA1 #x904F) (#xEEA2 #x9050) (#xEEA3 #x9051) (#xEEA4 #x9052) (#xEEA5 #x900E) (#xEEA6 #x9049) (#xEEA7 #x903E) (#xEEA8 #x9056) (#xEEA9 #x9058) (#xEEAA #x905E) (#xEEAB #x9068) (#xEEAC #x906F) (#xEEAD #x9076) (#xEEAE #x96A8) (#xEEAF #x9072) (#xEEB0 #x9082) (#xEEB1 #x907D) (#xEEB2 #x9081) (#xEEB3 #x9080) (#xEEB4 #x908A) (#xEEB5 #x9089) (#xEEB6 #x908F) (#xEEB7 #x90A8) (#xEEB8 #x90AF) (#xEEB9 #x90B1) (#xEEBA #x90B5) (#xEEBB #x90E2) (#xEEBC #x90E4) (#xEEBD #x6248) (#xEEBE #x90DB) (#xEEBF #x9102) (#xEEC0 #x9112) (#xEEC1 #x9119) (#xEEC2 #x9132) (#xEEC3 #x9130) (#xEEC4 #x914A) (#xEEC5 #x9156) (#xEEC6 #x9158) (#xEEC7 #x9163) (#xEEC8 #x9165) (#xEEC9 #x9169) (#xEECA #x9173) (#xEECB #x9172) (#xEECC #x918B) (#xEECD #x9189) (#xEECE #x9182) (#xEECF #x91A2) (#xEED0 #x91AB) (#xEED1 #x91AF) (#xEED2 #x91AA) (#xEED3 #x91B5) (#xEED4 #x91B4) (#xEED5 #x91BA) (#xEED6 #x91C0) (#xEED7 #x91C1) (#xEED8 #x91C9) (#xEED9 #x91CB) (#xEEDA #x91D0) (#xEEDB #x91D6) (#xEEDC #x91DF) (#xEEDD #x91E1) (#xEEDE #x91DB) (#xEEDF #x91FC) (#xEEE0 #x91F5) (#xEEE1 #x91F6) (#xEEE2 #x921E) (#xEEE3 #x91FF) (#xEEE4 #x9214) (#xEEE5 #x922C) (#xEEE6 #x9215) (#xEEE7 #x9211) (#xEEE8 #x925E) (#xEEE9 #x9257) (#xEEEA #x9245) (#xEEEB #x9249) (#xEEEC #x9264) (#xEEED #x9248) (#xEEEE #x9295) (#xEEEF #x923F) (#xEEF0 #x924B) (#xEEF1 #x9250) (#xEEF2 #x929C) (#xEEF3 #x9296) (#xEEF4 #x9293) (#xEEF5 #x929B) (#xEEF6 #x925A) (#xEEF7 #x92CF) (#xEEF8 #x92B9) (#xEEF9 #x92B7) (#xEEFA #x92E9) (#xEEFB #x930F) (#xEEFC #x92FA) (#xEEFD #x9344) (#xEEFE #x932E) (#xEFA1 #x9319) (#xEFA2 #x9322) (#xEFA3 #x931A) (#xEFA4 #x9323) (#xEFA5 #x933A) (#xEFA6 #x9335) (#xEFA7 #x933B) (#xEFA8 #x935C) (#xEFA9 #x9360) (#xEFAA #x937C) (#xEFAB #x936E) (#xEFAC #x9356) (#xEFAD #x93B0) (#xEFAE #x93AC) (#xEFAF #x93AD) (#xEFB0 #x9394) (#xEFB1 #x93B9) (#xEFB2 #x93D6) (#xEFB3 #x93D7) (#xEFB4 #x93E8) (#xEFB5 #x93E5) (#xEFB6 #x93D8) (#xEFB7 #x93C3) (#xEFB8 #x93DD) (#xEFB9 #x93D0) (#xEFBA #x93C8) (#xEFBB #x93E4) (#xEFBC #x941A) (#xEFBD #x9414) (#xEFBE #x9413) (#xEFBF #x9403) (#xEFC0 #x9407) (#xEFC1 #x9410) (#xEFC2 #x9436) (#xEFC3 #x942B) (#xEFC4 #x9435) (#xEFC5 #x9421) (#xEFC6 #x943A) (#xEFC7 #x9441) (#xEFC8 #x9452) (#xEFC9 #x9444) (#xEFCA #x945B) (#xEFCB #x9460) (#xEFCC #x9462) (#xEFCD #x945E) (#xEFCE #x946A) (#xEFCF #x9229) (#xEFD0 #x9470) (#xEFD1 #x9475) (#xEFD2 #x9477) (#xEFD3 #x947D) (#xEFD4 #x945A) (#xEFD5 #x947C) (#xEFD6 #x947E) (#xEFD7 #x9481) (#xEFD8 #x947F) (#xEFD9 #x9582) (#xEFDA #x9587) (#xEFDB #x958A) (#xEFDC #x9594) (#xEFDD #x9596) (#xEFDE #x9598) (#xEFDF #x9599) (#xEFE0 #x95A0) (#xEFE1 #x95A8) (#xEFE2 #x95A7) (#xEFE3 #x95AD) (#xEFE4 #x95BC) (#xEFE5 #x95BB) (#xEFE6 #x95B9) (#xEFE7 #x95BE) (#xEFE8 #x95CA) (#xEFE9 #x6FF6) (#xEFEA #x95C3) (#xEFEB #x95CD) (#xEFEC #x95CC) (#xEFED #x95D5) (#xEFEE #x95D4) (#xEFEF #x95D6) (#xEFF0 #x95DC) (#xEFF1 #x95E1) (#xEFF2 #x95E5) (#xEFF3 #x95E2) (#xEFF4 #x9621) (#xEFF5 #x9628) (#xEFF6 #x962E) (#xEFF7 #x962F) (#xEFF8 #x9642) (#xEFF9 #x964C) (#xEFFA #x964F) (#xEFFB #x964B) (#xEFFC #x9677) (#xEFFD #x965C) (#xEFFE #x965E) (#xF0A1 #x965D) (#xF0A2 #x965F) (#xF0A3 #x9666) (#xF0A4 #x9672) (#xF0A5 #x966C) (#xF0A6 #x968D) (#xF0A7 #x9698) (#xF0A8 #x9695) (#xF0A9 #x9697) (#xF0AA #x96AA) (#xF0AB #x96A7) (#xF0AC #x96B1) (#xF0AD #x96B2) (#xF0AE #x96B0) (#xF0AF #x96B4) (#xF0B0 #x96B6) (#xF0B1 #x96B8) (#xF0B2 #x96B9) (#xF0B3 #x96CE) (#xF0B4 #x96CB) (#xF0B5 #x96C9) (#xF0B6 #x96CD) (#xF0B7 #x894D) (#xF0B8 #x96DC) (#xF0B9 #x970D) (#xF0BA #x96D5) (#xF0BB #x96F9) (#xF0BC #x9704) (#xF0BD #x9706) (#xF0BE #x9708) (#xF0BF #x9713) (#xF0C0 #x970E) (#xF0C1 #x9711) (#xF0C2 #x970F) (#xF0C3 #x9716) (#xF0C4 #x9719) (#xF0C5 #x9724) (#xF0C6 #x972A) (#xF0C7 #x9730) (#xF0C8 #x9739) (#xF0C9 #x973D) (#xF0CA #x973E) (#xF0CB #x9744) (#xF0CC #x9746) (#xF0CD #x9748) (#xF0CE #x9742) (#xF0CF #x9749) (#xF0D0 #x975C) (#xF0D1 #x9760) (#xF0D2 #x9764) (#xF0D3 #x9766) (#xF0D4 #x9768) (#xF0D5 #x52D2) (#xF0D6 #x976B) (#xF0D7 #x9771) (#xF0D8 #x9779) (#xF0D9 #x9785) (#xF0DA #x977C) (#xF0DB #x9781) (#xF0DC #x977A) (#xF0DD #x9786) (#xF0DE #x978B) (#xF0DF #x978F) (#xF0E0 #x9790) (#xF0E1 #x979C) (#xF0E2 #x97A8) (#xF0E3 #x97A6) (#xF0E4 #x97A3) (#xF0E5 #x97B3) (#xF0E6 #x97B4) (#xF0E7 #x97C3) (#xF0E8 #x97C6) (#xF0E9 #x97C8) (#xF0EA #x97CB) (#xF0EB #x97DC) (#xF0EC #x97ED) (#xF0ED #x9F4F) (#xF0EE #x97F2) (#xF0EF #x7ADF) (#xF0F0 #x97F6) (#xF0F1 #x97F5) (#xF0F2 #x980F) (#xF0F3 #x980C) (#xF0F4 #x9838) (#xF0F5 #x9824) (#xF0F6 #x9821) (#xF0F7 #x9837) (#xF0F8 #x983D) (#xF0F9 #x9846) (#xF0FA #x984F) (#xF0FB #x984B) (#xF0FC #x986B) (#xF0FD #x986F) (#xF0FE #x9870) (#xF1A1 #x9871) (#xF1A2 #x9874) (#xF1A3 #x9873) (#xF1A4 #x98AA) (#xF1A5 #x98AF) (#xF1A6 #x98B1) (#xF1A7 #x98B6) (#xF1A8 #x98C4) (#xF1A9 #x98C3) (#xF1AA #x98C6) (#xF1AB #x98E9) (#xF1AC #x98EB) (#xF1AD #x9903) (#xF1AE #x9909) (#xF1AF #x9912) (#xF1B0 #x9914) (#xF1B1 #x9918) (#xF1B2 #x9921) (#xF1B3 #x991D) (#xF1B4 #x991E) (#xF1B5 #x9924) (#xF1B6 #x9920) (#xF1B7 #x992C) (#xF1B8 #x992E) (#xF1B9 #x993D) (#xF1BA #x993E) (#xF1BB #x9942) (#xF1BC #x9949) (#xF1BD #x9945) (#xF1BE #x9950) (#xF1BF #x994B) (#xF1C0 #x9951) (#xF1C1 #x9952) (#xF1C2 #x994C) (#xF1C3 #x9955) (#xF1C4 #x9997) (#xF1C5 #x9998) (#xF1C6 #x99A5) (#xF1C7 #x99AD) (#xF1C8 #x99AE) (#xF1C9 #x99BC) (#xF1CA #x99DF) (#xF1CB #x99DB) (#xF1CC #x99DD) (#xF1CD #x99D8) (#xF1CE #x99D1) (#xF1CF #x99ED) (#xF1D0 #x99EE) (#xF1D1 #x99F1) (#xF1D2 #x99F2) (#xF1D3 #x99FB) (#xF1D4 #x99F8) (#xF1D5 #x9A01) (#xF1D6 #x9A0F) (#xF1D7 #x9A05) (#xF1D8 #x99E2) (#xF1D9 #x9A19) (#xF1DA #x9A2B) (#xF1DB #x9A37) (#xF1DC #x9A45) (#xF1DD #x9A42) (#xF1DE #x9A40) (#xF1DF #x9A43) (#xF1E0 #x9A3E) (#xF1E1 #x9A55) (#xF1E2 #x9A4D) (#xF1E3 #x9A5B) (#xF1E4 #x9A57) (#xF1E5 #x9A5F) (#xF1E6 #x9A62) (#xF1E7 #x9A65) (#xF1E8 #x9A64) (#xF1E9 #x9A69) (#xF1EA #x9A6B) (#xF1EB #x9A6A) (#xF1EC #x9AAD) (#xF1ED #x9AB0) (#xF1EE #x9ABC) (#xF1EF #x9AC0) (#xF1F0 #x9ACF) (#xF1F1 #x9AD1) (#xF1F2 #x9AD3) (#xF1F3 #x9AD4) (#xF1F4 #x9ADE) (#xF1F5 #x9ADF) (#xF1F6 #x9AE2) (#xF1F7 #x9AE3) (#xF1F8 #x9AE6) (#xF1F9 #x9AEF) (#xF1FA #x9AEB) (#xF1FB #x9AEE) (#xF1FC #x9AF4) (#xF1FD #x9AF1) (#xF1FE #x9AF7) (#xF2A1 #x9AFB) (#xF2A2 #x9B06) (#xF2A3 #x9B18) (#xF2A4 #x9B1A) (#xF2A5 #x9B1F) (#xF2A6 #x9B22) (#xF2A7 #x9B23) (#xF2A8 #x9B25) (#xF2A9 #x9B27) (#xF2AA #x9B28) (#xF2AB #x9B29) (#xF2AC #x9B2A) (#xF2AD #x9B2E) (#xF2AE #x9B2F) (#xF2AF #x9B32) (#xF2B0 #x9B44) (#xF2B1 #x9B43) (#xF2B2 #x9B4F) (#xF2B3 #x9B4D) (#xF2B4 #x9B4E) (#xF2B5 #x9B51) (#xF2B6 #x9B58) (#xF2B7 #x9B74) (#xF2B8 #x9B93) (#xF2B9 #x9B83) (#xF2BA #x9B91) (#xF2BB #x9B96) (#xF2BC #x9B97) (#xF2BD #x9B9F) (#xF2BE #x9BA0) (#xF2BF #x9BA8) (#xF2C0 #x9BB4) (#xF2C1 #x9BC0) (#xF2C2 #x9BCA) (#xF2C3 #x9BB9) (#xF2C4 #x9BC6) (#xF2C5 #x9BCF) (#xF2C6 #x9BD1) (#xF2C7 #x9BD2) (#xF2C8 #x9BE3) (#xF2C9 #x9BE2) (#xF2CA #x9BE4) (#xF2CB #x9BD4) (#xF2CC #x9BE1) (#xF2CD #x9C3A) (#xF2CE #x9BF2) (#xF2CF #x9BF1) (#xF2D0 #x9BF0) (#xF2D1 #x9C15) (#xF2D2 #x9C14) (#xF2D3 #x9C09) (#xF2D4 #x9C13) (#xF2D5 #x9C0C) (#xF2D6 #x9C06) (#xF2D7 #x9C08) (#xF2D8 #x9C12) (#xF2D9 #x9C0A) (#xF2DA #x9C04) (#xF2DB #x9C2E) (#xF2DC #x9C1B) (#xF2DD #x9C25) (#xF2DE #x9C24) (#xF2DF #x9C21) (#xF2E0 #x9C30) (#xF2E1 #x9C47) (#xF2E2 #x9C32) (#xF2E3 #x9C46) (#xF2E4 #x9C3E) (#xF2E5 #x9C5A) (#xF2E6 #x9C60) (#xF2E7 #x9C67) (#xF2E8 #x9C76) (#xF2E9 #x9C78) (#xF2EA #x9CE7) (#xF2EB #x9CEC) (#xF2EC #x9CF0) (#xF2ED #x9D09) (#xF2EE #x9D08) (#xF2EF #x9CEB) (#xF2F0 #x9D03) (#xF2F1 #x9D06) (#xF2F2 #x9D2A) (#xF2F3 #x9D26) (#xF2F4 #x9DAF) (#xF2F5 #x9D23) (#xF2F6 #x9D1F) (#xF2F7 #x9D44) (#xF2F8 #x9D15) (#xF2F9 #x9D12) (#xF2FA #x9D41) (#xF2FB #x9D3F) (#xF2FC #x9D3E) (#xF2FD #x9D46) (#xF2FE #x9D48) (#xF3A1 #x9D5D) (#xF3A2 #x9D5E) (#xF3A3 #x9D64) (#xF3A4 #x9D51) (#xF3A5 #x9D50) (#xF3A6 #x9D59) (#xF3A7 #x9D72) (#xF3A8 #x9D89) (#xF3A9 #x9D87) (#xF3AA #x9DAB) (#xF3AB #x9D6F) (#xF3AC #x9D7A) (#xF3AD #x9D9A) (#xF3AE #x9DA4) (#xF3AF #x9DA9) (#xF3B0 #x9DB2) (#xF3B1 #x9DC4) (#xF3B2 #x9DC1) (#xF3B3 #x9DBB) (#xF3B4 #x9DB8) (#xF3B5 #x9DBA) (#xF3B6 #x9DC6) (#xF3B7 #x9DCF) (#xF3B8 #x9DC2) (#xF3B9 #x9DD9) (#xF3BA #x9DD3) (#xF3BB #x9DF8) (#xF3BC #x9DE6) (#xF3BD #x9DED) (#xF3BE #x9DEF) (#xF3BF #x9DFD) (#xF3C0 #x9E1A) (#xF3C1 #x9E1B) (#xF3C2 #x9E1E) (#xF3C3 #x9E75) (#xF3C4 #x9E79) (#xF3C5 #x9E7D) (#xF3C6 #x9E81) (#xF3C7 #x9E88) (#xF3C8 #x9E8B) (#xF3C9 #x9E8C) (#xF3CA #x9E92) (#xF3CB #x9E95) (#xF3CC #x9E91) (#xF3CD #x9E9D) (#xF3CE #x9EA5) (#xF3CF #x9EA9) (#xF3D0 #x9EB8) (#xF3D1 #x9EAA) (#xF3D2 #x9EAD) (#xF3D3 #x9761) (#xF3D4 #x9ECC) (#xF3D5 #x9ECE) (#xF3D6 #x9ECF) (#xF3D7 #x9ED0) (#xF3D8 #x9ED4) (#xF3D9 #x9EDC) (#xF3DA #x9EDE) (#xF3DB #x9EDD) (#xF3DC #x9EE0) (#xF3DD #x9EE5) (#xF3DE #x9EE8) (#xF3DF #x9EEF) (#xF3E0 #x9EF4) (#xF3E1 #x9EF6) (#xF3E2 #x9EF7) (#xF3E3 #x9EF9) (#xF3E4 #x9EFB) (#xF3E5 #x9EFC) (#xF3E6 #x9EFD) (#xF3E7 #x9F07) (#xF3E8 #x9F08) (#xF3E9 #x76B7) (#xF3EA #x9F15) (#xF3EB #x9F21) (#xF3EC #x9F2C) (#xF3ED #x9F3E) (#xF3EE #x9F4A) (#xF3EF #x9F52) (#xF3F0 #x9F54) (#xF3F1 #x9F63) (#xF3F2 #x9F5F) (#xF3F3 #x9F60) (#xF3F4 #x9F61) (#xF3F5 #x9F66) (#xF3F6 #x9F67) (#xF3F7 #x9F6C) (#xF3F8 #x9F6A) (#xF3F9 #x9F77) (#xF3FA #x9F72) (#xF3FB #x9F76) (#xF3FC #x9F95) (#xF3FD #x9F9C) (#xF3FE #x9FA0) (#xF4A1 #x582F) (#xF4A2 #x69C7) (#xF4A3 #x9059) (#xF4A4 #x7464) (#xF4A5 #x51DC) (#xF4A6 #x7199) ))

Common Lisp

.lisp

cac-t-u-s/om-sharp

GPL-3.0

9/19/2024, 11:25:22 AM (Europe/Amsterdam)

73663d7db642e83d9a72533ff08970f92bba08c391650ef1b2bbab05a96d3b88

tests.lisp

cac-t-u-s_om-sharp/src/api/foreign-interface/ffi/babel/tests/tests.lisp

;;;; -*- Mode: lisp; indent-tabs-mode: nil -*- ;;; ;;; tests.lisp --- Unit and regression tests for Babel. ;;; ;;; Copyright (C) 2007-2009, Luis Oliveira <[email protected]> ;;; ;;; Permission is hereby granted, free of charge, to any person ;;; obtaining a copy of this software and associated documentation ;;; files (the "Software"), to deal in the Software without ;;; restriction, including without limitation the rights to use, copy, ;;; modify, merge, publish, distribute, sublicense, and/or sell copies ;;; of the Software, and to permit persons to whom the Software is ;;; furnished to do so, subject to the following conditions: ;;; ;;; The above copyright notice and this permission notice shall be ;;; included in all copies or substantial portions of the Software. ;;; ;;; THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, ;;; EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF ;;; MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND ;;; NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT ;;; HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, ;;; WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, ;;; OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER ;;; DEALINGS IN THE SOFTWARE. (in-package #:cl-user) (defpackage #:babel-tests (:use #:common-lisp #:babel #:babel-encodings #:hu.dwim.stefil) (:export #:run)) (in-package #:babel-tests) (defun run () (funcall-test-with-feedback-message 'babel-tests)) (defsuite* (babel-tests :in root-suite)) (defun ub8v (&rest contents) (make-array (length contents) :element-type '(unsigned-byte 8) :initial-contents contents)) (defun make-ub8-vector (size) (make-array size :element-type '(unsigned-byte 8) :initial-element 0)) (defmacro returns (form &rest values) "Asserts, through EQUALP, that FORM returns VALUES." `(is (equalp (multiple-value-list ,form) (list ,@values)))) (defmacro defstest (name form &body return-values) "Similar to RT's DEFTEST." `(deftest ,name () (returns ,form ,@(mapcar (lambda (x) `',x) return-values)))) (defun fail (control-string &rest arguments) (hu.dwim.stefil::record-failure 'hu.dwim.stefil::failed-assertion :format-control control-string :format-arguments arguments)) (defun expected (expected &key got) (fail "expected ~A, got ~A instead" expected got)) (enable-sharp-backslash-syntax) ;;;; Simple tests using ASCII (defstest enc.ascii.1 (string-to-octets "abc" :encoding :ascii) #(97 98 99)) (defstest enc.ascii.2 (string-to-octets (string #\uED) :encoding :ascii :errorp nil) #(#x1a)) (deftest enc.ascii.3 () (handler-case (string-to-octets (string #\uED) :encoding :ascii :errorp t) (character-encoding-error (c) (is (eql 0 (character-coding-error-position c))) (is (eq :ascii (character-coding-error-encoding c))) (is (eql #xed (character-encoding-error-code c)))) (:no-error (result) (expected 'character-encoding-error :got result)))) (defstest dec.ascii.1 (octets-to-string (ub8v 97 98 99) :encoding :ascii) "abc") (deftest dec.ascii.2 () (handler-case (octets-to-string (ub8v 97 128 99) :encoding :ascii :errorp t) (character-decoding-error (c) (is (equalp #(128) (character-decoding-error-octets c))) (is (eql 1 (character-coding-error-position c))) (is (eq :ascii (character-coding-error-encoding c)))) (:no-error (result) (expected 'character-decoding-error :got result)))) (defstest dec.ascii.3 (octets-to-string (ub8v 97 255 98 99) :encoding :ascii :errorp nil) #(#\a #\Sub #\b #\c)) (defstest oct-count.ascii.1 (string-size-in-octets "abc" :encoding :ascii) 3 3) (defstest char-count.ascii.1 (vector-size-in-chars (ub8v 97 98 99) :encoding :ascii) 3 3) ;;;; UTF-8 (defstest char-count.utf-8.1 ;; "ni hao" in hanzi with the last octet missing (vector-size-in-chars (ub8v 228 189 160 229 165) :errorp nil) 2 5) (deftest char-count.utf-8.2 () ;; same as above with the last 2 octets missing (handler-case (vector-size-in-chars (ub8v 228 189 160 229) :errorp t) (end-of-input-in-character (c) (is (equalp #(229) (character-decoding-error-octets c))) (is (eql 3 (character-coding-error-position c))) (is (eq :utf-8 (character-coding-error-encoding c)))) (:no-error (result) (expected 'end-of-input-in-character :got result)))) ;;; Lispworks bug? ;; #+lispworks ;; (pushnew 'dec.utf-8.1 rtest::*expected-failures*) (defstest dec.utf-8.1 (octets-to-string (ub8v 228 189 160 229) :errorp nil) #(#\u4f60 #\ufffd)) (deftest dec.utf-8.2 () (handler-case (octets-to-string (ub8v 228 189 160 229) :errorp t) (end-of-input-in-character (c) (is (equalp #(229) (character-decoding-error-octets c))) (is (eql 3 (character-coding-error-position c))) (is (eq :utf-8 (character-coding-error-encoding c)))) (:no-error (result) (expected 'end-of-input-in-character :got result)))) ;;;; UTF-16 ;;; Test that the BOM is not being counted as a character. (deftest char-count.utf-16.bom () (is (eql (vector-size-in-chars (ub8v #xfe #xff #x00 #x55 #x00 #x54 #x00 #x46) :encoding :utf-16) 3)) (is (eql (vector-size-in-chars (ub8v #xff #xfe #x00 #x55 #x00 #x54 #x00 #x46) :encoding :utf-16) 3))) ;;;; UTF-32 ;;; RT: check that UTF-32 characters without a BOM are treated as ;;; little-endian. (deftest endianness.utf-32.no-bom () (is (string= "a" (octets-to-string (ub8v 0 0 0 97) :encoding :utf-32)))) ;;;; MORE TESTS (defparameter *standard-characters* "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!$\"'(),_-./:;?+<=>#%&*@[\\]{|}`^~") ;;; Testing consistency by encoding and decoding a simple string for ;;; all character encodings. (deftest rw-equiv.1 () (dolist (*default-character-encoding* (list-character-encodings)) (let ((octets (string-to-octets *standard-characters*))) (is (string= (octets-to-string octets) *standard-characters*))))) ;;; FIXME: assumes little-endianness. Easily fixable when we ;;; implement the BE and LE variants of :UTF-16. (deftest concatenate-strings-to-octets-equiv.1 () (let ((foo (octets-to-string (ub8v 102 195 186 195 186) :encoding :utf-8)) (bar (octets-to-string (ub8v 98 195 161 114) :encoding :utf-8))) ;; note: FOO and BAR are not ascii (is (equalp (concatenate-strings-to-octets :utf-8 foo bar) (ub8v 102 195 186 195 186 98 195 161 114))) (is (equalp (concatenate-strings-to-octets :utf-16 foo bar) (ub8v 102 0 250 0 250 0 98 0 225 0 114 0))))) ;;;; Testing against files generated by GNU iconv. (defun test-file (name type) (let ((sys-pn (truename (asdf:system-definition-pathname (asdf:find-system 'babel-tests))))) (make-pathname :name name :type type :directory (append (pathname-directory sys-pn) '("tests")) :defaults sys-pn))) (defun read-test-file (name type) (with-open-file (in (test-file name type) :element-type '(unsigned-byte 8)) (let* ((data (loop for byte = (read-byte in nil nil) until (null byte) collect byte))) (make-array (length data) :element-type '(unsigned-byte 8) :initial-contents data)))) (deftest test-encoding (enc &optional input-enc-name) (let* ((*default-character-encoding* enc) (enc-name (string-downcase (symbol-name enc))) (utf8-octets (read-test-file enc-name "txt-utf8")) (foo-octets (read-test-file (or input-enc-name enc-name) "txt")) (utf8-string (octets-to-string utf8-octets :encoding :utf-8 :errorp t)) (foo-string (octets-to-string foo-octets :errorp t))) (is (string= utf8-string foo-string)) (is (= (length foo-string) (vector-size-in-chars foo-octets :errorp t))) (unless (member enc '(:utf-16 :utf-32)) ;; FIXME: skipping UTF-16 and UTF-32 because of the BOMs and ;; because the input might not be in native-endian order so the ;; comparison will fail there. (let ((new-octets (string-to-octets foo-string :errorp t))) (is (equalp new-octets foo-octets)) (is (eql (length foo-octets) (string-size-in-octets foo-string :errorp t))))))) (deftest iconv-test () (dolist (enc '(:ascii :ebcdic-us :utf-8 :utf-16 :utf-32)) (case enc (:utf-16 (test-encoding :utf-16 "utf-16-with-le-bom")) (:utf-32 (test-encoding :utf-32 "utf-32-with-le-bom"))) (test-encoding enc))) ;;; RT: accept encoding objects in LOOKUP-MAPPING etc. (defstest encoding-objects.1 (string-to-octets "abc" :encoding (get-character-encoding :ascii)) #(97 98 99)) (defmacro with-sharp-backslash-syntax (&body body) `(let ((*readtable* (copy-readtable *readtable*))) (set-sharp-backslash-syntax-in-readtable) ,@body)) (defstest sharp-backslash.1 (with-sharp-backslash-syntax (loop for string in '("#\\a" "#\\u" "#\\ued") collect (char-code (read-from-string string)))) (97 117 #xed)) (deftest sharp-backslash.2 () (signals reader-error (with-sharp-backslash-syntax (read-from-string "#\\u12zz")))) (deftest test-read-from-string (string object position) "Test that (read-from-string STRING) returns values OBJECT and POSITION." (multiple-value-bind (obj pos) (read-from-string string) (is (eql object obj)) (is (eql position pos)))) ;;; RT: our #\ reader didn't honor *READ-SUPPRESS*. (deftest sharp-backslash.3 () (with-sharp-backslash-syntax (let ((*read-suppress* t)) (test-read-from-string "#\\ujunk" nil 7) (test-read-from-string "#\\u12zz" nil 7)))) ;;; RT: the slow implementation of with-simple-vector was buggy. (defstest string-to-octets.1 (code-char (aref (string-to-octets "abc" :start 1 :end 2) 0)) #\b) (defstest simple-base-string.1 (string-to-octets (coerce "abc" 'base-string) :encoding :ascii) #(97 98 99)) ;;; For now, disable this tests for Lisps that are strict about ;;; non-character code points. In the future, simply mark them as ;;; expected failures. #-(or abcl ccl) (progn (defstest utf-8b.1 (string-to-octets (coerce #(#\a #\b #\udcf0) 'unicode-string) :encoding :utf-8b) #(97 98 #xf0)) (defstest utf-8b.2 (octets-to-string (ub8v 97 98 #xcd) :encoding :utf-8b) #(#\a #\b #\udccd)) (defstest utf-8b.3 (octets-to-string (ub8v 97 #xf0 #xf1 #xff #x01) :encoding :utf-8b) #(#\a #\udcf0 #\udcf1 #\udcff #\udc01)) (deftest utf-8b.4 () (let* ((octets (coerce (loop repeat 8192 collect (random (+ #x82))) '(array (unsigned-byte 8) (*)))) (string (octets-to-string octets :encoding :utf-8b))) (is (equalp octets (string-to-octets string :encoding :utf-8b)))))) ;;; The following tests have been adapted from SBCL's ;;; tests/octets.pure.lisp file. (deftest ensure-roundtrip-ascii () (let ((octets (make-ub8-vector 128))) (dotimes (i 128) (setf (aref octets i) i)) (let* ((str (octets-to-string octets :encoding :ascii)) (oct2 (string-to-octets str :encoding :ascii))) (is (= (length octets) (length oct2))) (is (every #'= octets oct2))))) (deftest test-8bit-roundtrip (enc) (let ((octets (make-ub8-vector 256))) (dotimes (i 256) (setf (aref octets i) i)) (let* ((str (octets-to-string octets :encoding enc))) ;; remove the undefined code-points because they translate ;; to #xFFFD and string-to-octets raises an error when ;; encoding #xFFFD (multiple-value-bind (filtered-str filtered-octets) (let ((s (make-array 0 :element-type 'character :adjustable t :fill-pointer 0)) (o (make-array 0 :element-type '(unsigned-byte 16) :adjustable t :fill-pointer 0))) (loop for i below 256 for c = (aref str i) when (/= (char-code c) #xFFFD) do (vector-push-extend c s) (vector-push-extend (aref octets i) o)) (values s o)) (let ((oct2 (string-to-octets filtered-str :encoding enc))) (is (eql (length filtered-octets) (length oct2))) (is (every #'eql filtered-octets oct2))))))) (defparameter *iso-8859-charsets* '(:iso-8859-1 :iso-8859-2 :iso-8859-3 :iso-8859-4 :iso-8859-5 :iso-8859-6 :iso-8859-7 :iso-8859-8 :iso-8859-9 :iso-8859-10 :iso-8859-11 :iso-8859-13 :iso-8859-14 :iso-8859-15 :iso-8859-16)) ;;; Don't actually see what comes out, but there shouldn't be any ;;; errors. (deftest iso-8859-roundtrip-no-checking () (loop for enc in *iso-8859-charsets* do (test-8bit-roundtrip enc))) (deftest ensure-roundtrip-latin () (loop for enc in '(:latin1 :latin9) do (test-8bit-roundtrip enc))) ;;; Latin-9 chars; the previous test checked roundtrip from ;;; octets->char and back, now test that the latin-9 characters did in ;;; fact appear during that trip. (deftest ensure-roundtrip-latin9 () (let ((l9c (map 'string #'code-char '(8364 352 353 381 382 338 339 376)))) (is (string= (octets-to-string (string-to-octets l9c :encoding :latin9) :encoding :latin9) l9c)))) ;; Expected to fail on Lisps that are strict about non-character code ;; points. Mark this as an expected failure when Stefil supports such ;; a feature. #-(or abcl ccl) (deftest code-char-nilness () (is (loop for i below unicode-char-code-limit never (null (code-char i))))) (deftest test-unicode-roundtrip (enc) (let ((string (make-string unicode-char-code-limit))) (dotimes (i unicode-char-code-limit) (setf (char string i) (if (or (<= #xD800 i #xDFFF) (<= #xFDD0 i #xFDEF) (eql (logand i #xFFFF) #xFFFF) (eql (logand i #xFFFF) #xFFFE)) #\? ; don't try to encode non-characters. (code-char i)))) (let ((string2 (octets-to-string (string-to-octets string :encoding enc :errorp t) :encoding enc :errorp t))) (is (eql (length string2) (length string))) (is (string= string string2))))) (deftest ensure-roundtrip.utf8 () (test-unicode-roundtrip :utf-8)) (deftest ensure-roundtrip.utf16 () (test-unicode-roundtrip :utf-16)) (deftest ensure-roundtrip.utf32 () (test-unicode-roundtrip :utf-32)) #+sbcl (progn (deftest test-encode-against-sbcl (enc) (let ((string (make-string unicode-char-code-limit))) (dotimes (i unicode-char-code-limit) (setf (char string i) (code-char i))) (loop for ch across string for babel = (string-to-octets (string ch) :encoding enc) for sbcl = (sb-ext:string-to-octets (string ch) :external-format enc) do (is (equalp babel sbcl))))) ;; not run automatically because it's a bit slow (1114112 assertions) (deftest (test-encode-against-sbcl.utf-8 :auto-call nil) () (test-encode-against-sbcl :utf-8))) (deftest non-ascii-bytes () (let ((octets (make-array 128 :element-type '(unsigned-byte 8) :initial-contents (loop for i from 128 below 256 collect i)))) (is (string= (octets-to-string octets :encoding :ascii :errorp nil) (make-string 128 :initial-element #\Sub))))) (deftest non-ascii-chars () (let ((string (make-array 128 :element-type 'character :initial-contents (loop for i from 128 below 256 collect (code-char i))))) (is (equalp (string-to-octets string :encoding :ascii :errorp nil) (make-array 128 :initial-element (char-code #\Sub)))))) ;;;; The following UTF-8 decoding tests are adapted from ;;;; <http://www.cl.cam.ac.uk/~mgk25/ucs/examples/UTF-8-test.txt>. (deftest utf8-decode-test (octets expected-results expected-errors) (let ((string (octets-to-string (coerce octets '(vector (unsigned-byte 8) *)) :encoding :utf-8 :errorp nil))) (is (string= expected-results string)) (is (= (count #\ufffd string) expected-errors)))) (deftest utf8-decode-tests (octets expected-results) (let ((expected-errors (count #\? expected-results)) (expected-results (substitute #\ufffd #\? expected-results))) (utf8-decode-test octets expected-results expected-errors) (utf8-decode-test (concatenate 'vector '(34) octets '(34)) (format nil "\"~A\"" expected-results) expected-errors))) (deftest utf8-too-big-characters () (utf8-decode-tests #(#xf4 #x90 #x80 #x80) "?") ; #x110000 (utf8-decode-tests #(#xf7 #xbf #xbf #xbf) "?") ; #x1fffff (utf8-decode-tests #(#xf8 #x88 #x80 #x80 #x80) "?") ; #x200000 (utf8-decode-tests #(#xfb #xbf #xbf #xbf #xbf) "?") ; #x3ffffff (utf8-decode-tests #(#xfc #x84 #x80 #x80 #x80 #x80) "?") ; #x4000000e (utf8-decode-tests #(#xfd #xbf #xbf #xbf #xbf #xbf) "?")) ; #x7fffffff (deftest utf8-unexpected-continuation-bytes () (utf8-decode-tests #(#x80) "?") (utf8-decode-tests #(#xbf) "?") (utf8-decode-tests #(#x80 #xbf) "??") (utf8-decode-tests #(#x80 #xbf #x80) "???") (utf8-decode-tests #(#x80 #xbf #x80 #xbf) "????") (utf8-decode-tests #(#x80 #xbf #x80 #xbf #x80) "?????") (utf8-decode-tests #(#x80 #xbf #x80 #xbf #x80 #xbf) "??????") (utf8-decode-tests #(#x80 #xbf #x80 #xbf #x80 #xbf #x80) "???????")) ;;; All 64 continuation bytes in a row. (deftest utf8-continuation-bytes () (apply #'utf8-decode-tests (loop for i from #x80 to #xbf collect i into bytes collect #\? into chars finally (return (list bytes (coerce chars 'string)))))) (deftest utf8-lonely-start-characters () (flet ((lsc (first last) (apply #'utf8-decode-tests (loop for i from first to last nconc (list i 32) into bytes nconc (list #\? #\Space) into chars finally (return (list bytes (coerce chars 'string))))) (apply #'utf8-decode-tests (loop for i from first to last collect i into bytes collect #\? into chars finally (return (list bytes (coerce chars 'string))))))) (lsc #xc0 #xdf) ; 2-byte sequence start chars (lsc #xe0 #xef) ; 3-byte (lsc #xf0 #xf7) ; 4-byte (lsc #xf8 #xfb) ; 5-byte (lsc #xfc #xfd))) ; 6-byte ;;; Otherwise incomplete sequences (last continuation byte missing) (deftest utf8-incomplete-sequences () (utf8-decode-tests #0=#(#xc0) "?") (utf8-decode-tests #1=#(#xe0 #x80) "?") (utf8-decode-tests #2=#(#xf0 #x80 #x80) "?") (utf8-decode-tests #3=#(#xf8 #x80 #x80 #x80) "?") (utf8-decode-tests #4=#(#xfc #x80 #x80 #x80 #x80) "?") (utf8-decode-tests #5=#(#xdf) "?") (utf8-decode-tests #6=#(#xef #xbf) "?") (utf8-decode-tests #7=#(#xf7 #xbf #xbf) "?") (utf8-decode-tests #8=#(#xfb #xbf #xbf #xbf) "?") (utf8-decode-tests #9=#(#xfd #xbf #xbf #xbf #xbf) "?") ;; All ten previous tests concatenated (utf8-decode-tests (concatenate 'vector #0# #1# #2# #3# #4# #5# #6# #7# #8# #9#) "??????????")) (deftest utf8-random-impossible-bytes () (utf8-decode-tests #(#xfe) "?") (utf8-decode-tests #(#xff) "?") (utf8-decode-tests #(#xfe #xfe #xff #xff) "????")) (deftest utf8-overlong-sequences-/ () (utf8-decode-tests #(#xc0 #xaf) "?") (utf8-decode-tests #(#xe0 #x80 #xaf) "?") (utf8-decode-tests #(#xf0 #x80 #x80 #xaf) "?") (utf8-decode-tests #(#xf8 #x80 #x80 #x80 #xaf) "?") (utf8-decode-tests #(#xfc #x80 #x80 #x80 #x80 #xaf) "?")) (deftest utf8-overlong-sequences-rubout () (utf8-decode-tests #(#xc1 #xbf) "?") (utf8-decode-tests #(#xe0 #x9f #xbf) "?") (utf8-decode-tests #(#xf0 #x8f #xbf #xbf) "?") (utf8-decode-tests #(#xf8 #x87 #xbf #xbf #xbf) "?") (utf8-decode-tests #(#xfc #x83 #xbf #xbf #xbf #xbf) "?")) (deftest utf8-overlong-sequences-null () (utf8-decode-tests #(#xc0 #x80) "?") (utf8-decode-tests #(#xe0 #x80 #x80) "?") (utf8-decode-tests #(#xf0 #x80 #x80 #x80) "?") (utf8-decode-tests #(#xf8 #x80 #x80 #x80 #x80) "?") (utf8-decode-tests #(#xfc #x80 #x80 #x80 #x80 #x80) "?")) ;;;; End of adapted SBCL tests. ;;; Expected to fail, for now. #+#:ignore (deftest utf8-illegal-code-positions () ;; single UTF-16 surrogates (utf8-decode-tests #(#xed #xa0 #x80) "?") (utf8-decode-tests #(#xed #xad #xbf) "?") (utf8-decode-tests #(#xed #xae #x80) "?") (utf8-decode-tests #(#xed #xaf #xbf) "?") (utf8-decode-tests #(#xed #xb0 #x80) "?") (utf8-decode-tests #(#xed #xbe #x80) "?") (utf8-decode-tests #(#xed #xbf #xbf) "?") ;; paired UTF-16 surrogates (utf8-decode-tests #(ed a0 80 ed b0 80) "??") (utf8-decode-tests #(ed a0 80 ed bf bf) "??") (utf8-decode-tests #(ed ad bf ed b0 80) "??") (utf8-decode-tests #(ed ad bf ed bf bf) "??") (utf8-decode-tests #(ed ae 80 ed b0 80) "??") (utf8-decode-tests #(ed ae 80 ed bf bf) "??") (utf8-decode-tests #(ed af bf ed b0 80) "??") (utf8-decode-tests #(ed af bf ed bf bf) "??") ;; other illegal code positions (utf8-decode-tests #(#xef #xbf #xbe) "?") ; #\uFFFE (utf8-decode-tests #(#xef #xbf #xbf) "?")) ; #\uFFFF ;;; A list of the ISO-8859 encodings where each element is a cons with ;;; the car being a keyword denoting the encoding and the cdr being a ;;; vector enumerating the corresponding character codes. ;;; ;;; It was auto-generated from files which can be found at ;;; <ftp://ftp.unicode.org/Public/MAPPINGS/ISO8859/>. ;;; ;;; Taken from flexi-streams. (defparameter *iso-8859-tables* '((:iso-8859-1 . #(0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255)) (:iso-8859-2 . #(0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 260 728 321 164 317 346 167 168 352 350 356 377 173 381 379 176 261 731 322 180 318 347 711 184 353 351 357 378 733 382 380 340 193 194 258 196 313 262 199 268 201 280 203 282 205 206 270 272 323 327 211 212 336 214 215 344 366 218 368 220 221 354 223 341 225 226 259 228 314 263 231 269 233 281 235 283 237 238 271 273 324 328 243 244 337 246 247 345 367 250 369 252 253 355 729)) (:iso-8859-3 . #(0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 294 728 163 164 65533 292 167 168 304 350 286 308 173 65533 379 176 295 178 179 180 181 293 183 184 305 351 287 309 189 65533 380 192 193 194 65533 196 266 264 199 200 201 202 203 204 205 206 207 65533 209 210 211 212 288 214 215 284 217 218 219 220 364 348 223 224 225 226 65533 228 267 265 231 232 233 234 235 236 237 238 239 65533 241 242 243 244 289 246 247 285 249 250 251 252 365 349 729)) (:iso-8859-4 . #(0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 260 312 342 164 296 315 167 168 352 274 290 358 173 381 175 176 261 731 343 180 297 316 711 184 353 275 291 359 330 382 331 256 193 194 195 196 197 198 302 268 201 280 203 278 205 206 298 272 325 332 310 212 213 214 215 216 370 218 219 220 360 362 223 257 225 226 227 228 229 230 303 269 233 281 235 279 237 238 299 273 326 333 311 244 245 246 247 248 371 250 251 252 361 363 729)) (:iso-8859-5 . #(0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 173 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 8470 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 167 1118 1119)) (:iso-8859-6 . #(0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 65533 65533 65533 164 65533 65533 65533 65533 65533 65533 65533 1548 173 65533 65533 65533 65533 65533 65533 65533 65533 65533 65533 65533 65533 65533 1563 65533 65533 65533 1567 65533 1569 1570 1571 1572 1573 1574 1575 1576 1577 1578 1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 65533 65533 65533 65533 65533 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615 1616 1617 1618 65533 65533 65533 65533 65533 65533 65533 65533 65533 65533 65533 65533 65533)) (:iso-8859-7 . #(0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 8216 8217 163 8364 8367 166 167 168 169 890 171 172 173 65533 8213 176 177 178 179 900 901 902 183 904 905 906 187 908 189 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 65533 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 65533)) (:iso-8859-8 . #(0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 65533 162 163 164 165 166 167 168 169 215 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 247 187 188 189 190 65533 65533 65533 65533 65533 65533 65533 65533 65533 65533 65533 65533 65533 65533 65533 65533 65533 65533 65533 65533 65533 65533 65533 65533 65533 65533 65533 65533 65533 65533 65533 65533 8215 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 65533 65533 8206 8207 65533)) (:iso-8859-9 . #(0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 286 209 210 211 212 213 214 215 216 217 218 219 220 304 350 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 287 241 242 243 244 245 246 247 248 249 250 251 252 305 351 255)) (:iso-8859-10 . #(0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 260 274 290 298 296 310 167 315 272 352 358 381 173 362 330 176 261 275 291 299 297 311 183 316 273 353 359 382 8213 363 331 256 193 194 195 196 197 198 302 268 201 280 203 278 205 206 207 208 325 332 211 212 213 214 360 216 370 218 219 220 221 222 223 257 225 226 227 228 229 230 303 269 233 281 235 279 237 238 239 240 326 333 243 244 245 246 361 248 371 250 251 252 253 254 312)) (:iso-8859-11 . #(0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 3585 3586 3587 3588 3589 3590 3591 3592 3593 3594 3595 3596 3597 3598 3599 3600 3601 3602 3603 3604 3605 3606 3607 3608 3609 3610 3611 3612 3613 3614 3615 3616 3617 3618 3619 3620 3621 3622 3623 3624 3625 3626 3627 3628 3629 3630 3631 3632 3633 3634 3635 3636 3637 3638 3639 3640 3641 3642 65533 65533 65533 65533 3647 3648 3649 3650 3651 3652 3653 3654 3655 3656 3657 3658 3659 3660 3661 3662 3663 3664 3665 3666 3667 3668 3669 3670 3671 3672 3673 3674 3675 65533 65533 65533 65533)) (:iso-8859-13 . #(0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 8221 162 163 164 8222 166 167 216 169 342 171 172 173 174 198 176 177 178 179 8220 181 182 183 248 185 343 187 188 189 190 230 260 302 256 262 196 197 280 274 268 201 377 278 290 310 298 315 352 323 325 211 332 213 214 215 370 321 346 362 220 379 381 223 261 303 257 263 228 229 281 275 269 233 378 279 291 311 299 316 353 324 326 243 333 245 246 247 371 322 347 363 252 380 382 8217)) (:iso-8859-14 . #(0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 7682 7683 163 266 267 7690 167 7808 169 7810 7691 7922 173 174 376 7710 7711 288 289 7744 7745 182 7766 7809 7767 7811 7776 7923 7812 7813 7777 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 372 209 210 211 212 213 214 7786 216 217 218 219 220 221 374 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 373 241 242 243 244 245 246 7787 248 249 250 251 252 253 375 255)) (:iso-8859-15 . #(0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 8364 165 352 167 353 169 170 171 172 173 174 175 176 177 178 179 381 181 182 183 382 185 186 187 338 339 376 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255)) (:iso-8859-16 . #(0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 260 261 321 8364 8222 352 167 353 169 536 171 377 173 378 379 176 177 268 322 381 8221 182 183 382 269 537 187 338 339 376 380 192 193 194 258 196 262 198 199 200 201 202 203 204 205 206 207 272 323 210 211 212 336 214 346 368 217 218 219 220 280 538 223 224 225 226 259 228 263 230 231 232 233 234 235 236 237 238 239 273 324 242 243 244 337 246 347 369 249 250 251 252 281 539 255)))) (deftest iso-8859-decode-check () (loop for enc in *iso-8859-charsets* for octets = (let ((octets (make-ub8-vector 256))) (dotimes (i 256 octets) (setf (aref octets i) i))) for string = (octets-to-string octets :encoding enc) do (is (equalp (map 'vector #'char-code string) (cdr (assoc enc *iso-8859-tables*)))))) (deftest character-out-of-range.utf-32 () (signals character-out-of-range (octets-to-string (ub8v 0 0 #xfe #xff 0 #x11 0 0) :encoding :utf-32 :errorp t))) ;;; RT: encoders and decoders were returning bogus values. (deftest encoder/decoder-retvals (encoding &optional (test-string "abc")) (let* ((mapping (lookup-mapping babel::*string-vector-mappings* encoding)) (strlen (length test-string)) ;; encoding (octet-precount (funcall (octet-counter mapping) test-string 0 strlen -1)) (array (make-array octet-precount :element-type '(unsigned-byte 8))) (encoded-octet-count (funcall (encoder mapping) test-string 0 strlen array 0)) ;; decoding (string (make-string strlen)) (char-precount (funcall (code-point-counter mapping) array 0 octet-precount -1)) (char-count (funcall (decoder mapping) array 0 octet-precount string 0))) (is (= octet-precount encoded-octet-count)) (is (= char-precount char-count)) (is (string= test-string string)))) (deftest encoder-and-decoder-return-values () (mapcar 'encoder/decoder-retvals (remove-if 'ambiguous-encoding-p (list-character-encodings))))

Common Lisp

.lisp

cac-t-u-s/om-sharp

GPL-3.0

9/19/2024, 11:25:22 AM (Europe/Amsterdam)

e1ef4760778a20587ee542d001a1a534f789b9a0609622ba980039d409e8bb83

benchmarks.lisp

cac-t-u-s_om-sharp/src/api/foreign-interface/ffi/babel/tests/benchmarks.lisp

;;;; -*- Mode: lisp; indent-tabs-mode: nil -*- ;;; ;;; benchmarks.lisp --- Benchmarks, Babel vs. other implementations. ;;; ;;; Copyright (C) 2007, Luis Oliveira <[email protected]> ;;; ;;; Permission is hereby granted, free of charge, to any person ;;; obtaining a copy of this software and associated documentation ;;; files (the "Software"), to deal in the Software without ;;; restriction, including without limitation the rights to use, copy, ;;; modify, merge, publish, distribute, sublicense, and/or sell copies ;;; of the Software, and to permit persons to whom the Software is ;;; furnished to do so, subject to the following conditions: ;;; ;;; The above copyright notice and this permission notice shall be ;;; included in all copies or substantial portions of the Software. ;;; ;;; THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, ;;; EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF ;;; MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND ;;; NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT ;;; HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, ;;; WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, ;;; OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER ;;; DEALINGS IN THE SOFTWARE. (defpackage #:babel-benchmarks (:use #:cl #:babel)) (in-package #:babel-benchmarks) (defun benchmark (enc file-name file-type &optional (n 100)) (let* ((octets (read-test-file file-name file-type)) (string (octets-to-string octets :encoding enc))) (write-line ";; testing SB-EXT:STRING-TO-OCTETS") (time (loop repeat n do (sb-ext:string-to-octets string :external-format enc))) (write-line ";; testing BABEL:STRING-TO-OCTETS") (time (loop repeat n do (string-to-octets string :encoding enc))) (write-line ";; testing SB-EXT:OCTETS-TO-STRING") (time (loop repeat n do (sb-ext:octets-to-string octets :external-format enc))) (write-line ";; testing BABEL:OCTETS-TO-STRING") (time (loop repeat n do (octets-to-string octets :encoding enc)))))

Common Lisp

.lisp

cac-t-u-s/om-sharp

GPL-3.0

9/19/2024, 11:25:22 AM (Europe/Amsterdam)

fea6bd1c655008368cdf676ec3688a3f6019bdb56d3b83a52095147ba64b60f4

streams.lisp

cac-t-u-s_om-sharp/src/api/foreign-interface/ffi/babel/tests/streams.lisp

;;;; -*- Mode: lisp; indent-tabs-mode: nil -*- ;;; ;;; streams.lisp --- Unit and regression tests for Babel streams. ;;; ;;; Copyright (C) 2007, Attila Lendva <[email protected]> ;;; ;;; Permission is hereby granted, free of charge, to any person ;;; obtaining a copy of this software and associated documentation ;;; files (the "Software"), to deal in the Software without ;;; restriction, including without limitation the rights to use, copy, ;;; modify, merge, publish, distribute, sublicense, and/or sell copies ;;; of the Software, and to permit persons to whom the Software is ;;; furnished to do so, subject to the following conditions: ;;; ;;; The above copyright notice and this permission notice shall be ;;; included in all copies or substantial portions of the Software. ;;; ;;; THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, ;;; EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF ;;; MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND ;;; NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT ;;; HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, ;;; WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, ;;; OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER ;;; DEALINGS IN THE SOFTWARE. (in-package #:babel-tests) (eval-when (:compile-toplevel :load-toplevel :execute) (use-package :babel-streams)) (deftest in-memory-vector-stream (with-output-to-sequence (output) ;; TODO use a better test lib and inject asserts for the file position ;(print (file-position output)) (write-sequence "éáőűú" output) ;(print (file-position output)) (write-char #\ű output) ;(print (file-position output)) (write-byte 12 output) (write-sequence (string-to-octets "körte") output) ;(print (file-position output)) ) #(195 169 195 161 197 145 197 177 195 186 197 177 12 107 195 182 114 116 101))

Common Lisp

.lisp

cac-t-u-s/om-sharp

GPL-3.0

9/19/2024, 11:25:22 AM (Europe/Amsterdam)

8f95fbcd49b68b3a072e0ff67e78c005d6435a0c5eba3b57f13e4f373ab6f5a6

picture-processing.lisp

cac-t-u-s_om-sharp/src/api/om-api-LW/picture-processing.lisp

;========================================================================= ; OM API ; Multiplatform API for OpenMusic ; LispWorks Implementation ;========================================================================= ; ; This program 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. ; ; This program 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 this program. If not, see <http://www.gnu.org/licenses/>. ; ;========================================================================= ; Authors: J. Bresson ;========================================================================= ;;;============================== ;;; Manipulation of pictures using LW ;;;============================== ;;; ALL THIS IS NOT USED AT ALL ATM (in-package :oa) (export '(om-create-picture om-picture-values om-picture-array om-save-picture) :om-api) ;;; !!! ARRAY EN BGRA (defun image-to-arrayvector (img) (ensure-pict-win) (let* ((intimg (om-internalize-image img)) (ia (gp::make-image-access *temp-pictlayout* intimg)) (w (gp:image-access-width ia)) (h (gp:image-access-height ia)) (bgra-vector (make-array (* h w 4) :element-type '(unsigned-byte 8))) (color-array (make-array (list h w 4) :element-type '(unsigned-byte 8) :displaced-to bgra-vector))) (gp::image-access-transfer-from-image ia) (gp:image-access-pixels-to-bgra ia bgra-vector) (gp::free-image-access ia) color-array)) (defmethod image-to-arraylist (img) (ensure-pict-win) (let* ((intimg (om-internalize-image img)) (ia (gp::make-image-access *temp-pictlayout* intimg)) (w (gp:image-access-width ia)) (h (gp:image-access-height ia)) color-array (color nil)) (gp::image-access-transfer-from-image ia) (setf color-array (loop for j from 0 to (- h 1) collect (loop for i from 0 to (- w 1) do (setf color (color::get-color-spec (color::ensure-rgb (color::unconvert-color *temp-pictlayout* (gp::image-access-pixel ia i j))))) collect (list (aref color 1) (aref color 2) (aref color 3) (if (> (length color) 4) (aref color 4) 1.0))))) (gp::free-image-access ia) ;(capi:destroy win) color-array)) (defun pix-list-to-image (color-array) (ensure-pict-win) (capi::hide-interface *temp-pictlayout* nil) (let* ((img (gp::make-image *temp-pictlayout* (length (car color-array)) (length color-array) :alpha t)) (ia (gp::make-image-access *temp-pictlayout* img))) (loop for line in color-array for j = 0 then (+ j 1) do (loop for pix in line for i = 0 then (+ i 1) do (setf (gp::image-access-pixel ia i j) (color::convert-color *temp-pictlayout* (if (consp pix) (color::make-rgb (nth 0 pix) (nth 1 pix) (nth 2 pix) (nth 3 pix)) (color::make-rgb pix pix pix 1)))))) (gp::image-access-transfer-to-image ia) (gp::free-image-access ia) ;(capi:destroy win) img)) ;;; !!! ARRAY EN BGRA (defun pix-array-to-image (array) (ensure-pict-win) (let ((color-array array) (h (array-dimension array 0)) (w (array-dimension array 1))) (when (= 2 (array-rank array)) (setf color-array (make-array (list h w 4) :element-type '(unsigned-byte 8))) (dolist (i h) (dolist (j w) (let ((pixel (aref array i j))) (cond ((numberp pixel) (setf (aref color-array i j 0) pixel) (setf (aref color-array i j 1) pixel) (setf (aref color-array i j 2) pixel) (setf (aref color-array i j 3) 1)) ((consp pixel) (setf (aref color-array i j 0) (car pixel)) (setf (aref color-array i j 1) (cadr pixel)) (setf (aref color-array i j 2) (caddr pixel)) (setf (aref color-array i j 3) (or (cadddr pixel) 1))))))) ) (let ((bgra-vector (make-array (* h w 4) :element-type '(unsigned-byte 8) :displaced-to color-array))) (or (and *temp-pictwin* *temp-pictlayout*) (init-pictwin)) (capi::hide-interface *temp-pictlayout* nil) (let* ((img (gp::make-image *temp-pictlayout* w h :alpha t)) (ia (gp::make-image-access *temp-pictlayout* img))) (gp:image-access-pixels-from-bgra ia bgra-vector) (gp::image-access-transfer-to-image ia) (gp::free-image-access ia) img) ))) (defun om-create-picture (array) (cond ((arrayp array) (pix-array-to-image array)) ((consp array) (pix-list-to-image array)) (t nil))) (defun om-picture-values (pict) (let ((w (car (capi::collect-interfaces 'om-abstract-window :screen :any :sort-by :visible))) (pictarray (image-to-arraylist pict))) (om-select-window w) pictarray)) (defun om-picture-array (pict) (let ((w (car (capi::collect-interfaces 'om-abstract-window :screen :any :sort-by :visible))) (pictarray (image-to-arrayvector pict))) (om-select-window w) pictarray)) (defmethod om-save-picture (pict path) (gp::write-external-image (om-externalize-image pict) path :if-exists :supersede) path) #| ;;; for internal-picture: (defmethod om-save-picture (pict path) (unwind-protect (gp:externalize-and-write-image *record-view* (om-internal-picture-to-pict pict *record-view*) path :if-exists :supersede :errorp nil) (gp:free-image *record-view* image)) (probe-file path)) |#

Common Lisp

.lisp

cac-t-u-s/om-sharp

GPL-3.0

9/19/2024, 11:25:22 AM (Europe/Amsterdam)

5037ee21dfc7282abb496336e705d1dfe4e7259b75eb33b9efc8ad0bfd59ada5

om-api.lisp

cac-t-u-s_om-sharp/src/api/om-api-LW/om-api.lisp

;========================================================================= ; OM API ; Multiplatform API for OpenMusic ; LispWorks Implementation ;========================================================================= ; ; This program 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. ; ; This program 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 this program. If not, see <http://www.gnu.org/licenses/>. ; ;========================================================================= ; Authors: J. Bresson, C. Agon ;========================================================================= (in-package :cl-user) (defpackage "OM-API" (:nicknames "OA") ;(:use "COMMON-LISP" "CL-USER" "OM-LISP" "CAPI" "LISPWORKS" "GP") (:use "COMMON-LISP" "LISPWORKS") ) (in-package :oa) (defparameter *api-directory* (pathname-directory (truename *load-pathname*))) (export '(om-api-init) :om-api) ;;; API INIT (defparameter *api-init-list* nil) (defun om-api-add-init-fun (fun-name) (unless (member fun-name *api-init-list* :test 'equal) (push fun-name *api-init-list*))) (defun om-api-init () (print "Initializing API") (mapc #'(lambda (fun) fun (funcall fun)) (reverse *api-init-list*))) (let ((api-files '("files" "processes" "scheduler" "tools" "system" "graphics" "graphic-object" "actions" "window" "layout" "view" "dialog-items" "draw" "transient-drawing" "icons-picts" "menu" "item-view" "item-tree" "cursor" "user-interface" "draganddrop" "tooltips" "libraries" "om-special" ))) (mapc #'(lambda (filename) (cl-user::compile&load (make-pathname :directory *api-directory* :name filename)) (terpri)) api-files))

Common Lisp

.lisp

cac-t-u-s/om-sharp

GPL-3.0

9/19/2024, 11:25:22 AM (Europe/Amsterdam)

91a498eee4022e9ffa1e9be90f7d7d905ab7bcbe7864bb4db01d8d626ec72b0c

scheduler.lisp

cac-t-u-s_om-sharp/src/api/om-api-LW/scheduler.lisp

;========================================================================= ; OM API ; Multiplatform API for OpenMusic ; LispWorks Implementation ;========================================================================= ; ; This program 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. ; ; This program 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 this program. If not, see <http://www.gnu.org/licenses/>. ; ;========================================================================= ; Authors: J. Bresson, C. Agon ;========================================================================= ;;=========================================================================== ; SCHEDULER ;;=========================================================================== (in-package :om-api) ;;;=================== ;;; export : ;;;=================== (export '( om-start-scheduler-old om-stop-scheduler-old om-delayed-funcall ) :om-api) (defvar *scheduler-timer* nil) (defun scheduler-fun () t) ;(defun om-start-scheduler (fun) ; (setq *scheduler-timer* (mp:make-named-timer 'om-scheduler fun nil)) ; (mp:schedule-timer *scheduler-timer* 1 0.01)) ;(defun om-stop-scheduler () ; (when *scheduler-timer* ; (mp:unschedule-timer *scheduler-timer*) ; (setf *scheduler-timer* nil))) (defun om-stop-scheduler-old () (when *scheduler-timer* (mp:process-kill *scheduler-timer*))) (defun om-start-scheduler-old (fun) (om-stop-scheduler-old) (setf *scheduler-timer* (mp:process-run-function "SCHEDULER" '(:priority 10) #'(lambda () (loop while t do (sleep 0.050) (funcall fun nil)))))) (defun om-delayed-funcall (time func &rest args) (when *scheduler-timer* (mp:unschedule-timer *scheduler-timer*)) (flet ((scheduler-fun () (apply func args))) (mp:schedule-timer *scheduler-timer* time))) (define-action "When quitting image" "Stop scheduler" 'om-stop-scheduler-old)

Common Lisp

.lisp

cac-t-u-s/om-sharp

GPL-3.0

9/19/2024, 11:25:22 AM (Europe/Amsterdam)

cc7ad5b36bafe363080703373b936a998e518eff4a5ab68c07014d62a38945c1

dialog-items.lisp

cac-t-u-s_om-sharp/src/api/om-api-LW/dialog-items.lisp

;========================================================================= ; OM API ; Multiplatform API for OpenMusic ; LispWorks Implementation ;========================================================================= ; ; This program 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. ; ; This program 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 this program. If not, see <http://www.gnu.org/licenses/>. ; ;========================================================================= ; Authors: J. Bresson, C. Agon ;========================================================================= ;========================================================================= ; DIALOG ITEMS CLASSES AND FUNCTIONS ;========================================================================= (in-package :om-api) (export '( om-make-di om-dialog-item-action om-dialog-item-action-function om-set-dialog-item-action-function om-dialog-item-text om-set-dialog-item-text om-enable-dialog-item om-dialog-item-enabled om-simple-text om-multi-text om-custom-edit-text om-editable-text om-set-text-focus om-set-text-completion om-complete-text om-copy-command om-cut-command om-paste-command om-select-all-command om-end-text-edit om-text-edit-view om-scroll-text-edit-view om-make-edit-view om-button om-check-box om-radio-button om-checked-p om-set-check-box om-single-item-list om-multi-item-list om-popup-list om-set-item-list om-get-item-list om-get-selected-item-index om-set-selected-item-index om-select-item-index om-unselect-item-index om-get-selected-item om-set-selected-item om-slider om-slider-value om-slider-increment om-set-slider-value om-get-slider-range om-get-slider-orientation om-simple-text om-list-item om-sort-list-by om-multicol-item-list ) :om-api) ;;;===================== ;;;ABSTRACT ;;;===================== (defclass om-standard-dialog-item (om-graphic-object) ((di-action :accessor di-action :initform nil :initarg :di-action :documentation "the main dialog-item action")) (:default-initargs :visible-border :default :callback-type :item :scroll-if-not-visible-p nil )) ;;;========== ;;; GENERAL API CALLS ;;;========== (defmethod om-subviews ((self om-standard-dialog-item)) nil) (defmethod om-get-view ((self om-standard-dialog-item)) self) (defmethod om-invalidate-view ((self om-standard-dialog-item)) (capi::redisplay self)) ;;;========== ;;; ACTION ;;;========== (defmethod om-dialog-item-action ((self om-standard-dialog-item)) (when (di-action self) (funcall (di-action self) self))) (defmethod om-set-dialog-item-action-function ((self om-standard-dialog-item) action) (setf (di-action self) action)) (defmethod om-dialog-item-action-function ((self om-standard-dialog-item)) (di-action self)) (defmethod om-enable-dialog-item ((self t) t-or-nil) nil) (defmethod om-dialog-item-enabled ((self t)) t) ;;;===================================== ;;; SPATIAL ATTRIBUTES (SIZE, POSITION) ;;;===================================== (defmethod om-dialog-item-text ((self om-standard-dialog-item)) (capi::item-text self)) (defmethod om-set-dialog-item-text ((self om-standard-dialog-item) text) (setf (capi::item-text self) text)) (defmethod om-view-position ((self om-standard-dialog-item)) (if (capi::interface-visible-p self) (let ((point (multiple-value-list (capi::pinboard-pane-position self)))) (om-make-point (first point) (second point))) (om-make-point (vx self) (vy self)))) (defmethod om-set-view-position ((self om-standard-dialog-item) pos-point) (capi::apply-in-pane-process self (lambda () (setf (capi::pinboard-pane-position self) (values (om-point-x pos-point) (om-point-y pos-point))) )) (setf (vx self) (om-point-x pos-point) (vy self) (om-point-y pos-point))) (defmethod om-view-size ((self om-standard-dialog-item)) (if (capi::interface-visible-p self) (let ((point (multiple-value-list (capi::pinboard-pane-size self)))) (om-make-point (first point) (second point))) (om-make-point (vw self) (vh self)))) (defmethod om-set-view-size ((self om-standard-dialog-item) size-point) (setf (vw self) (om-point-x size-point) (vh self) (om-point-y size-point)) (when (capi::interface-visible-p self) (capi::apply-in-pane-process self (lambda () (capi::set-hint-table self (list :default-width (om-point-x size-point) :defalut-height (om-point-y size-point) :visible-min-width (om-point-x size-point) :visible-min-height (om-point-y size-point) ;:internal-min-width (om-point-x size-point) :internal-min-height (om-point-y size-point) ;:internal-max-width (om-point-x size-point) :internal-max-height (om-point-y size-point) :visible-max-width (om-point-x size-point) :visible-max-height (om-point-y size-point) )) (when (and (numberp (om-point-x size-point)) (numberp (om-point-y size-point))) (setf (capi::pinboard-pane-size self) (values (om-point-x size-point) (om-point-y size-point)))) (setf (capi::pinboard-pane-position self) (values (vx self) (vy self))) )) ) (di-after-settings self)) ;;;===================================== ; CONSTRUCTOR ;;;===================================== (defun dialog-item-scrollbar-h (scroll) (or (equal scroll :h) (equal scroll t))) (defun dialog-item-scrollbar-v (scroll) (or (equal scroll :v) (equal scroll t))) (defmethod special-bg ((self t)) nil) (defmethod di-after-settings ((self t)) nil) (defun om-make-di (class &rest other-attributes &key position size (text "") container font bg-color fg-color (enabled t) print border (checked-p nil) cancel default focus range items sort-styles (scrollbars nil) selection (direction :horizontal) (value 0) di-action edit-action begin-edit-action completion resizable &allow-other-keys) (let* ((wi (if size (om-point-x size) 20)) (hi (if size (om-point-y size) 16)) (shift #+macosx -5 #-macosx 0) (x (and position (+ (om-point-x position) shift))) (y (and position (+ (om-point-y position) shift)))) (multiple-value-bind (w h) (adjust-size class wi hi) (let ((di (apply 'make-instance (append (list class ;:x x :y y :default-x x :default-y y ;:external-min-width (max w 30) ;:external-max-width w :initial-constraints (list :visible-min-width w :visible-min-height h) :visible-min-width w :visible-max-width (if (or (equal resizable t) (equal resizable :w)) nil w) ;:internal-min-width w ;:internal-max-width w :external-min-height h :visible-min-height h :visible-max-height (if (or (equal resizable t) (equal resizable :h)) nil h) ;:internal-min-height h ;:internal-max-height (print h) :text text :font font :enabled enabled :di-action di-action :edit-action edit-action :begin-edit-action begin-edit-action :background (or (and (om-color-p bg-color) (omcolor-c bg-color)) #+cocoa :transparent #-cocoa :background) :foreground (and (om-color-p fg-color) (omcolor-c fg-color)) :color-function (when (or (functionp fg-color) (and (symbolp fg-color) (fboundp fg-color))) #'(lambda (list-panel item state) (declare (ignore list-panel state)) (let ((col (funcall fg-color item))) (and col (omcolor-c col))))) :sort-descriptions (convert-sort-styles sort-styles) :selected checked-p :default-p default :cancel-p cancel :items items :start (or (first range) 0) :end (or (second range) 100) :orientation direction :start-point :default :slug-start value :internal-border 0 :title-adjust t :accepts-focus-p enabled :horizontal-scroll (dialog-item-scrollbar-h scrollbars) :vertical-scroll (dialog-item-scrollbar-v scrollbars) :visible-border border ;;; only for text-edit :allows-newline-p nil :in-place-completion-function (when completion #'(lambda (item str) (declare (ignore item)) (or (funcall completion str) (progn (capi::beep-pane) :destroy)))) :allow-other-keys t ) ;;; other attributes/keywords of the dialog-items other-attributes )))) (when print (setf (capi::collection-print-function di) print)) (when selection (om-set-selected-item di selection)) (when (or bg-color (special-bg di)) (om-set-bg-color di (or bg-color (special-bg di)))) (when position (setf (vx di) x (vy di) y )) (when size (setf (vw di) w (vh di) h )) (when container (om-add-subviews container di)) (when font (om-set-font di font)) (di-after-settings di) (if focus (capi::set-pane-focus di)) (when completion (om-complete-text di)) di)))) (defun adjust-size (class w h) #+linux (values (or (and (numberp w) (round w 3/4)) w) (or (and (numberp h) (round h 3/4)) h)) #-linux (if (subtypep class 'om-editable-text) #+windows (values (- w 10) (- h 10)) #-windows (values w h) (values w h)) ) ;============================= ; SIMPLE TEXT ;============================= (defclass om-simple-text (om-standard-dialog-item capi::title-pane) ()) (defmethod om-set-dialog-item-text ((self om-simple-text) text) (capi:apply-in-pane-process self #'(lambda () (setf (capi::title-pane-text self) text)))) (defmethod om-dialog-item-text ((self om-simple-text)) (capi::title-pane-text self)) ;================= ; TEXT MULTI-LINES ;================= (defclass om-multi-text (om-standard-dialog-item capi::display-pane) () (:default-initargs :accepts-focus-p nil :callback 'om-dialog-item-action)) (defmethod om-dialog-item-text ((self om-multi-text)) (capi::display-pane-text self)) (defmethod om-set-dialog-item-text ((self om-multi-text) text) (capi:apply-in-pane-process self #'(setf capi:display-pane-text) text self)) (defmethod om-enable-dialog-item ((self om-multi-text) t-or-nil) (setf (capi::simple-pane-enabled self) t-or-nil)) (defmethod om-dialog-item-enabled ((self om-multi-text)) (capi::simple-pane-enabled self)) (defmethod om-copy-command ((self om-multi-text)) (capi::set-clipboard self (om-dialog-item-text self))) ;============================= ; TEXT EDIT CUSTOM ;============================= ;; cursor = nil (no edit), int (pos in text) or list (b e) for selection. (defclass om-custom-edit-text (om-standard-dialog-item capi::title-pane) ((cursor-pos :accessor cursor-pos :initform nil))) ;============================= ; TEXT EDIT SYSTEM ;============================= (defclass om-editable-text (om-standard-dialog-item capi::text-input-pane) ((begin-edit-action :accessor begin-edit-action :initarg :begin-edit-action :initform nil :documentation "called when the text edit starts") (edit-action :accessor edit-action :initarg :edit-action :initform nil :documentation "called when the text is edited")) (:default-initargs :visible-border #+windows t #-windows nil :navigation-callback 'text-edit-special-action :callback 'text-edit-validate-action :change-callback 'text-edit-changed-action ; :change-callback-type '(:element :data) :editing-callback 'text-edited-action ;;; EDITING START-STOP )) (defmethod om-text-edit-begin-action ((self om-editable-text)) (when (begin-edit-action self) (funcall (begin-edit-action self) self))) (defmethod om-text-edit-action ((self om-editable-text)) (if (edit-action self) (funcall (edit-action self) self))) ;;; prevents further action calls (defmethod om-end-text-edit ((self om-editable-text)) (setf (edit-action self) nil (di-action self) nil)) (defmethod om-view-click-handler ((self om-editable-text) position) nil) (defmethod special-bg ((self om-editable-text)) (om-def-color :light-gray)) (defun text-edit-validate-action (self) (om-dialog-item-action self)) ;;; :tab-forward :tab-backward :return ;;; :shift-return :enter :shift-enter (defun text-edit-special-action (self action) (cond ((equal action :enter) (om-dialog-item-action self)) ((equal action :return) (if (capi::text-input-allows-newline-p self) (let ((rec (capi::clipboard self))) (capi::set-clipboard self (string #\Newline)) (capi::text-input-pane-paste self) (capi::set-clipboard self rec)) (om-dialog-item-action self) )) ((equal action :tab-forward) (om-view-key-handler self :om-key-tab)) )) (defun text-edited-action (self action) (case action (:start (om-text-edit-begin-action self)) (:end (om-dialog-item-action self)) )) (defun text-edit-changed-action (text self win position) (declare (ignore text win position)) (om-text-edit-action self) ;(unless (or (string-equal text "") (> position (length text))) ; (om-view-key-handler self (elt text (max 0 (- position 1))))) ) (defmethod om-dialog-item-text ((self om-editable-text)) (capi::text-input-pane-text self)) (defmethod om-set-dialog-item-text ((self om-editable-text) text) (capi::apply-in-pane-process self #'(lambda () (setf (capi::text-input-pane-text self) text) ;(setf (capi:text-input-pane-caret-position self) ; (length (capi:text-input-pane-text self))) ))) (defmethod om-enable-dialog-item ((self om-editable-text) t-or-nil) (setf (capi::text-input-pane-enabled self) t-or-nil)) (defmethod om-dialog-item-enabled ((self om-editable-text)) (capi::text-input-pane-enabled self)) (defmethod om-copy-command ((self om-editable-text)) ;(capi::set-clipboard self (om-dialog-item-text self)) (capi::text-input-pane-copy self)) (defmethod om-paste-command ((self om-editable-text)) (let ((pos (capi::text-input-pane-selection self)) (txt (capi::clipboard self))) (unless (capi::text-input-allows-newline-p self) (capi::set-clipboard self (substitute #\Space #\Newline txt))) (capi::text-input-pane-paste self) (capi::set-clipboard self txt) (capi::set-text-input-pane-selection self (+ pos (length txt)) (+ pos (length txt))) )) (defmethod om-cut-command ((self om-editable-text)) (capi::text-input-pane-cut self)) (defmethod om-select-all-command ((self om-editable-text)) (capi::set-text-input-pane-selection self 0 (length (capi::text-input-pane-text self)))) (defmethod om-set-text-focus ((self om-editable-text) &optional select-contents) (om-set-focus self) (if select-contents (capi::set-text-input-pane-selection self 0 (length (capi::text-input-pane-text self))) (capi::set-text-input-pane-selection self 0 0))) (defmethod om-set-text-completion ((self om-editable-text) completion-fun) (capi::apply-in-pane-process self #'(lambda () (setf (capi::text-input-pane-completion-function self) completion-fun) (capi::text-input-pane-complete-text self) ))) (defmethod om-complete-text ((self om-editable-text)) (when (capi::text-input-pane-completion-function self) (capi::apply-in-pane-process self #'capi::text-input-pane-in-place-complete self))) ;================= ; EDIT MULTI-LINES ;================= (defclass om-text-edit-view (om-editable-text capi::multi-line-text-input-pane) () (:default-initargs :external-min-height nil :external-max-height nil)) ;(defmethod di-set-focus ((self om-text-edit-view)) ; (capi::set-pane-focus self) ; (capi::set-text-input-pane-selection self 0 (length (capi::text-input-pane-text self)))) (defmethod om-paste-command ((self om-text-edit-view)) (capi::text-input-pane-paste self)) ;=============== ; BUTTON ;=============== ;;; these will apply to all the following subclasses of capi::button (defmethod om-enable-dialog-item ((self capi::button) t-or-nil) (setf (capi::button-enabled self) t-or-nil)) (defmethod om-dialog-item-enabled ((self capi::button)) (capi::button-enabled self)) (defclass om-button (om-standard-dialog-item capi::push-button) () (:default-initargs :callback 'om-dialog-item-action)) ;=============== ; CHECK-BOX ;=============== (defclass om-check-box (om-standard-dialog-item capi::check-button) () (:default-initargs #+win32 :accepts-focus-p #+win32 nil :selection-callback 'om-dialog-item-action :retract-callback 'om-dialog-item-action)) (defmethod om-checked-p ((self om-check-box)) (capi::button-selected self)) (defmethod om-set-check-box ((self om-check-box) check?) (capi:apply-in-pane-process self #'(lambda () (setf (capi::button-selected self) check?)))) ;--------om-radio-button (defclass om-radio-button (om-standard-dialog-item capi::radio-button) ((button-group :initarg :button-group :initform nil :accessor button-group)) (:default-initargs :callback 'om-dialog-item-action)) (defmethod om-radio-button-p ((self om-radio-button)) t) (defmethod om-radio-button-p ((self t)) nil) (defmethod om-dialog-item-action ((self om-radio-button)) (let ((container (capi::element-parent self))) (when container (let ((elems (capi::pane-children container))) (loop for item in elems do (when (and (om-radio-button-p item) (not (equal item self)) (equal (button-group item) (button-group self))) (om-set-check-box item nil))))) (call-next-method))) (defmethod om-checked-p ((self om-radio-button)) (capi::button-selected self)) (defmethod om-set-check-box ((self om-radio-button) check?) (setf (capi::button-selected self) check?)) ;--------om-item-list abstract (defclass om-item-list (om-standard-dialog-item capi::list-panel) () (:default-initargs :callback-type '(:collection) :selection-callback 'om-dialog-item-action :action-callback 'double-click-on-list ;:vertical-scroll t :test-function 'string-equal)) (defclass om-list-item (capi::item) ()) (defmethod di-after-settings ((self om-item-list)) (if (remove nil (map 'list 'stringp (capi::collection-items self))) (setf (capi::collection-test-function self) 'string-equal) (setf (capi::collection-test-function self) 'equal) )) (defmethod special-bg ((self om-item-list)) (om-def-color :white)) (defun vector-col-to-list (v) (loop for i from 0 to (- (length v) 1) collect (elt v i))) (defmethod om-set-item-list ((self om-item-list) names) (setf (capi::collection-items self) names)) (defmethod om-get-item-list ((self om-item-list)) (vector-col-to-list (capi::collection-items self ))) (defmethod om-get-selected-item-index ((self om-item-list)) (capi::choice-selection self)) (defmethod om-set-selected-item-index ((self om-item-list) ind) (setf (capi::choice-selection self) ind)) (defmethod double-click-on-list ((self om-item-list)) nil) (defun convert-sort-styles (styles) (loop for style in styles collect (capi:make-sorting-description :type (car style) :sort (nth (1+ (position :sort (cadr style))) (cadr style)) :reverse-sort (nth (1+ (position :reverse (cadr style))) (cadr style))))) (defmethod om-sort-list-by ((self om-item-list) style) (capi:sorted-object-sort-by self style) (setf (capi::collection-items self) (capi::sort-object-items-by self (capi::collection-items self)))) (defmethod om-invalidate-view ((self om-item-list)) ;(capi:map-collection-items self (map nil #'(lambda (item) (capi::redisplay-collection-item self item)) (capi::collection-items self))) ;--------om-single-item-list (defclass om-single-item-list (om-item-list) () (:default-initargs :interaction :single-selection :retract-callback 'item-list-unselect)) (defmethod item-list-unselect ((self om-single-item-list)) (unless (capi::choice-selection self) (setf (capi::choice-selection self) 0) )) (defmethod om-select-item-index ((self om-single-item-list) i) (setf (capi::choice-selection self) i)) (defmethod om-unselect-item-index ((self om-single-item-list) i) (when (and (capi::choice-selection self) (= (capi::choice-selection self) i)) (setf (capi::choice-selection self) nil))) (defmethod om-get-selected-item ((self om-single-item-list)) (capi::choice-selected-item self)) (defmethod om-set-selected-item ((self om-single-item-list) item) (setf (capi::choice-selected-item self) item)) (defmethod om-dialog-item-action ((self om-single-item-list)) (call-next-method)) ;--------om-multi-item-list (defclass om-multi-item-list (om-item-list) () (:default-initargs :interaction #+win32 :multiple-selection #-win32 :extended-selection :right-click-selection-behavior :clicked/restore/restore :extend-callback 'om-dialog-item-action :retract-callback 'om-dialog-item-action)) ;;; :multiple-selection (defmethod om-select-item-index ((self om-multi-item-list) i) (setf (capi::choice-selection self) (union (capi::choice-selection self) (if (listp i) i (list i))))) (defmethod om-unselect-item-index ((self om-multi-item-list) i) (setf (capi::choice-selection self) (remove i (capi::choice-selection self)))) (defmethod om-get-selected-item ((self om-multi-item-list)) (capi::choice-selected-items self)) (defmethod om-set-selected-item ((self om-multi-item-list) items) (setf (capi::choice-selected-items self) (if (listp items) items (list items)))) ;--------multi-column-list (defclass om-multicol-item-list (om-multi-item-list capi::multi-column-list-panel) () (:default-initargs :callback-type '(:collection) :selection-callback 'om-dialog-item-action :action-callback 'double-click-on-list :interaction #+win32 :multiple-selection #-win32 :extended-selection :right-click-selection-behavior :clicked/restore/restore :extend-callback 'om-dialog-item-action :retract-callback 'om-dialog-item-action :test-function 'string-equal)) ;--------om-slider (defclass om-slider (om-standard-dialog-item capi::slider) ((increment :initarg :increment :initform 1 :accessor increment)) (:default-initargs :callback 'om-slider-item-action :show-value-p t)) (defmethod om-slider-value ((self om-slider)) (* (round (capi::range-slug-start self) (increment self)) (increment self))) (defmethod om-slider-increment ((self om-slider)) (increment self)) (defmethod om-set-slider-value ((self om-slider) (value integer)) (setf (capi::range-slug-start self) value)) (defmethod om-slider-item-action ((self om-standard-dialog-item) value type) (when (di-action self) (funcall (di-action self) self))) (defmethod om-get-slider-range ((self om-slider)) (list (capi::range-start self) (capi::range-end self))) (defmethod om-get-slider-orientation ((self om-slider)) (capi::range-orientation self)) ;--------om-popup-list (defclass om-popup-list (om-standard-dialog-item capi::option-pane) ((value :initform nil :initarg :value :accessor value)) (:default-initargs :callback-type '(:collection) :selection-callback 'om-dialog-item-action :test-function 'equal :separator-item "-")) (defmethod initialize-instance :after ((self om-popup-list) &rest l) (when (value self) (let ((pos (position (value self) (vector-col-to-list (capi::collection-items self )) :test (if (stringp (value self)) 'string-equal 'equal)))) (when pos (setf (capi::choice-selection self) pos))))) (defmethod om-dialog-item-action ((self om-popup-list)) (when (di-action self) (funcall (di-action self) self))) (defmethod om-get-item-list ((self om-popup-list)) (vector-col-to-list (capi::collection-items self))) (defmethod om-set-item-list ((self om-popup-list) names) (setf (capi::collection-items self) names)) (defmethod om-enable-dialog-item ((self om-popup-list) t-or-nil) (setf (capi::option-pane-enabled self) t-or-nil)) (defmethod om-dialog-item-enabled ((self om-popup-list)) (capi::option-pane-enabled self)) ;;; !!! (defmethod om-get-selected-item ((self om-popup-list)) (nth (capi::choice-selection self) (om-get-item-list self))) (defmethod om-get-selected-item-index ((self om-popup-list)) (capi::choice-selection self)) (defmethod om-set-selected-item-index ((self om-popup-list) pos) (setf (capi::choice-selection self) pos)) (defmethod om-set-selected-item ((self om-popup-list) str) (let ((pos (position str (om-get-item-list self) :test 'equal))) (when pos (setf (capi::choice-selection self) pos)))) (defmethod om-select-item-index ((self om-popup-list) index) (setf (capi::choice-selection self) index))

Common Lisp

.lisp

cac-t-u-s/om-sharp

GPL-3.0

9/19/2024, 11:25:22 AM (Europe/Amsterdam)

9245c24bd651a740e87f8301975556d6a070af692d3a49ca78fa2642f0546816

item-view.lisp

cac-t-u-s_om-sharp/src/api/om-api-LW/item-view.lisp

;========================================================================= ; OM API ; Multiplatform API for OpenMusic ; LispWorks Implementation ;========================================================================= ; ; This program 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. ; ; This program 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 this program. If not, see <http://www.gnu.org/licenses/>. ; ;========================================================================= ; Authors: J. Bresson, C. Agon ;========================================================================= ;;=========================================================================== ; INTERNAL SUBVIEW CLASSES OPTIMIZED FOR DRAWING ;;=========================================================================== (export '(om-item-view om-item-line om-item-text om-set-text) :om-api) (in-package :oa) ;;; no subview ;;; optimized display ;;; => requires being on a view for better drawing/focus ! (defclass om-item-view (om-graphic-object om-interactive-object capi::pinboard-object) ;; capi::drawn-pinboard-object ((item-container :initarg :item-container :accessor item-container :initform nil) (item-x :initarg :item-x :accessor item-x :initform 0) (item-y :initarg :item-y :accessor item-y :initform 0)) ;(:default-initargs :display-callback 'item-draw-callback) ) (defmethod initialize-instance :after ((self om-item-view) &rest args) (om-create-callback self)) (defmethod om-create-callback ((self om-item-view)) nil) (defun om-make-graphic-object (class &rest attributes &key (position (om-make-point 0 0)) (size (om-make-point 10 10)) font text bg-color fg-color &allow-other-keys) (let* ((x (or (om-point-x position) 0)) (y (or (om-point-y position) 0)) (w (om-point-x size)) (h (om-point-y size)) (view (apply 'make-instance (append (list class :width w :height nil :default-x x :default-y y :default-width w :default-height h :visible-min-width w :visible-min-height h :visible-max-width w :visible-max-height h :help-string text :vx x :vy y :vw w :vh h :allow-other-keys t) attributes)))) (when fg-color (om-set-fg-color view fg-color)) (when bg-color (om-set-bg-color view bg-color)) (om-set-font view (or font (om-def-font :normal))) view)) (defmethod om-item-view-p ((self t)) nil) (defmethod om-item-view-p ((self om-item-view)) t) (defmethod update-for-subviews-changes ((self om-item-view) &optional (recursive nil)) (when (and (item-container self) (initialized-p (item-container self))) (update-for-subviews-changes (item-container self) nil))) (defmethod internal-add-subview ((self om-view) (subview om-item-view)) (call-next-method) (setf (item-container subview) self) (setf (item-subviews self) (append (item-subviews self) (list subview))) (update-po-position subview) (mapcar #'(lambda (sv) (po-add-subview subview sv)) (vsubviews subview))) (defmethod internal-add-subview ((self om-abstract-window) (subview om-item-view)) (call-next-method) (setf (item-container subview) (capi::pane-layout self)) (setf (item-subviews (capi::pane-layout self)) (append (item-subviews (capi::pane-layout self)) (list subview))) (mapcar #'(lambda (sv) (po-add-subview subview sv)) (vsubviews subview))) (defmethod internal-add-subview ((self om-item-view) (subview om-item-view)) (call-next-method) (po-add-subview self subview)) ;;; recursively set the top-level layout for pinboard-objects (defmethod po-add-subview ((self om-item-view) (subview om-item-view)) (setf (item-container subview) (item-container self)) (when (item-container self) (setf (item-subviews (item-container self)) (append (item-subviews (item-container self)) (list subview))) (update-po-position subview)) (mapcar #'(lambda (sv) (po-add-subview subview sv)) (vsubviews subview))) (defmethod internal-remove-subview ((self om-view) (subview om-item-view)) (mapcar #'(lambda (sv) (po-remove-subview subview sv)) (vsubviews subview)) (setf (item-container subview) nil) (setf (item-subviews self) (remove subview (item-subviews self))) (capi::apply-in-pane-process self (lambda () (capi::manipulate-pinboard self subview :delete))) (call-next-method)) (defmethod internal-remove-subview ((self om-abstract-window) (subview om-item-view)) (mapcar #'(lambda (sv) (po-remove-subview subview sv)) (vsubviews subview)) (setf (item-container subview) nil) (setf (item-subviews (capi::pane-layout self)) (remove subview (item-subviews (capi::pane-layout self)))) (capi::apply-in-pane-process (capi::pane-layout self) (lambda () (capi::manipulate-pinboard (capi::pane-layout self) subview :delete))) (call-next-method)) (defmethod internal-remove-subview ((self om-item-view) (subview om-item-view)) (po-remove-subview self subview) (call-next-method)) (defmethod po-remove-subview ((self om-item-view) (subview om-item-view)) (mapcar #'(lambda (sv) (po-remove-subview subview sv)) (vsubviews subview)) (setf (item-subviews (item-container self)) (remove subview (item-subviews (item-container self)))) (capi::apply-in-pane-process (item-container self) (lambda () (capi::manipulate-pinboard (item-container self) subview :delete))) (setf (item-container subview) nil)) (defmethod om-subviews ((self om-item-view)) (vsubviews self)) (defun update-po-position (self) (when (and (vcontainer self) (item-container self)) (capi::apply-in-pane-process (item-container self) (lambda () (let ((abs-pos (om-convert-coordinates (om-view-position self) (vcontainer self) (item-container self)))) (setf (item-x self) (om-point-x abs-pos) (item-y self) (om-point-y abs-pos)) (setf (capi::pinboard-pane-position self) (values (item-x self) (item-y self))) (capi::set-hint-table self (list :x (om-point-x abs-pos) :y (om-point-y abs-pos) :visible-min-width (vw self) :visible-min-height (vh self) :visible-max-width t :visible-max-height t)) (mapc 'update-po-position (vsubviews self)))) ))) (defmethod om-set-view-position ((self om-item-view) pos-point) (setf (vx self) (om-point-x pos-point) (vy self) (om-point-y pos-point)) (update-po-position self)) (defmethod om-view-position ((self om-item-view)) (om-make-point (vx self) (vy self))) (defmethod om-view-position ((self t)) (om-make-point 0 0)) (defmethod position-in-view ((self om-item-view)) (om-view-position self)) (defmethod om-mouse-position ((view om-item-view)) (om-convert-coordinates (internal-mouse-position (item-container view)) (item-container view) view)) (defmacro om-with-redisplay-area ((view x y w h) &body body) `(let (ret-value) (setf (mask ,view) (list ,x ,y ,w ,h)) (let ((ret-value (progn ,@body))) (setf (mask ,view) nil) ret-value))) (defmethod om-set-view-size ((self om-item-view) size-point) ;(capi::resize-pinboard-object self :width (om-point-x size-point) :height (om-point-y size-point)) (setf (vw self) (om-point-x size-point)) (setf (vh self) (om-point-y size-point)) (capi:apply-in-pane-process (item-container self) #'(lambda () (setf (capi::pinboard-pane-size self) (values (om-point-x size-point) (om-point-y size-point))) (capi::set-hint-table self (list :visible-min-width (vw self) :visible-min-height (vh self) :visible-max-width t :visible-max-height t)) ))) (defmethod om-view-size ((self om-item-view)) (om-make-point (vw self) (vh self))) (defmethod om-get-view ((self om-item-view)) (or (capi::pinboard-object-pinboard self) (item-container self))) (defmethod om-set-bg-color ((self om-item-view) color) (let ((col (when color (omcolor-c color)))) (capi:apply-in-pane-process (item-container self) #'(lambda () (setf (capi::pinboard-object-graphics-arg self :background) (if (equal col :transparent) nil col)) (capi:redraw-pinboard-object self) )) )) (defmethod om-get-bg-color ((self om-item-view)) (make-omcolor :c (capi::pinboard-object-graphics-arg self :background))) (defmethod om-set-fg-color ((self om-item-view) color) (let ((col (when color (omcolor-c color)))) (capi:apply-in-pane-process (item-container self) #'(lambda () (setf (capi::pinboard-object-graphics-arg self :foreground) col) (capi:redraw-pinboard-object self) )))) (defmethod om-get-fg-color ((self om-item-view)) (make-omcolor :c (capi::pinboard-object-graphics-arg self :foreground))) (defmethod om-get-font ((self om-item-view)) (let ((font (capi::pinboard-object-graphics-arg self :font))) (when font (if (gp::font-description-p font) font (gp::font-description font))))) (defmethod om-set-font ((self capi::pinboard-object) font) (setf (capi::pinboard-object-graphics-arg self :font) font) (capi:redraw-pinboard-object self)) (defmethod om-set-focus ((self om-item-view)) (when (item-container self) (capi::set-pane-focus (item-container self)))) (defmethod capi::draw-pinboard-object (pane (self om-item-view) &key x y w h) (declare (ignore x y w h)) (call-next-method) (capi::apply-in-pane-process pane 'draw-item-view pane self)) (defun draw-item-view (pane po) (let ((old-stream *curstream*)) (setf *curstream* pane) (multiple-value-bind (pox poy) (capi::pinboard-pane-position po) (let ((font (if (gp::font-description-p (om-get-font po)) (gp::find-best-font pane (om-get-font po)) (om-get-font po)))) (gp::set-graphics-port-coordinates pane :left (- pox) :top (- poy)) (gp::with-graphics-state (pane :font font ;:mask (list (item-x po) (item-y po) (vw po) (vh po)) :foreground (or (capi::pinboard-object-graphics-arg po :foreground) :black) :background (capi::pinboard-object-graphics-arg po :background)) (capi::with-geometry po ;(oa::om-with-clip-rect po ; capi::%x% capi::%y% ;capi::%width% capi::%height% ;0 0 ; (item-x po) (item-y po) ;(vw po) (vh po) (om-draw-contents po) ; ) ) (gp::set-graphics-port-coordinates pane :left 0 :top 0) (setf *curstream* old-stream) ))))) (defmethod om-invalidate-view ((self om-item-view)) (when (om-get-view self) (multiple-value-bind (pox poy) (capi::pinboard-pane-position self) (when pox ;;; otherwise the view is not yet positioned (capi::apply-in-pane-process (om-get-view self) 'gp::invalidate-rectangle (om-get-view self) (- pox 3) (- poy 3) (+ (vw self) 6) (+ (vh self) 6)))))) ;;;=========================== ;;; SPECIAL CASES ;;;=========================== #+cocoa (defclass om-internal-view (om-view) () (:default-initargs :background :transparent)) #-cocoa (defclass om-internal-view (om-item-view) ()) (defclass om-item-line (om-item-view capi::line-pinboard-object) ()) (defclass om-item-text (om-item-view) ((text :accessor text :initarg :text :initform "") (bg :accessor bg :initarg :bg :initform nil) (fg :accessor fg :initarg :fg :initform nil) (border :accessor border :initarg :border :initform nil) )) (defmethod om-draw-contents ((self om-item-text)) (when (border self) (om-draw-rect 0 0 (vw self) (vh self) :color (om-def-color :gray))) (gp:draw-x-y-adjusted-string *curstream* (text self) 0 -1 :y-adjust :top)) ;(defmethod capi:draw-pinboard-object (pinboard (text om-item-text) &key) ; (capi:with-geometry text ; (let (;(foreground (foreground text)) ; ;(background (capi:simple-pane-background pinboard)) ; ;(filled (filled text)) ; ) ; (print text) ; (gp:draw-x-y-adjusted-string pinboard ; (text text) ; 0 ;capi:%x%;; ; 0 ;capi:%y;% ; :y-adjust ;:top ; ;:foreground (if filled background foreground) ; ;:background (if filled foreground background) ; ;:block (filled text) ; )))) (defmethod om-set-text ((self om-item-text) text) (setf (text self) text) (capi:redraw-pinboard-object self)) ;#-cocoa ;(defmethod (setf vcontainer) :around ((cont om-graphic-object) (view om-transparent-view)) ; (call-next-method) ; (om-set-bg-color view (om-get-bg-color cont)) ; (mapc #'(lambda (v) (setf (vcontainer v) view)) (om-subviews view))) ;#-cocoa ;(defmethod (setf vcontainer) :around ((cont om-graphic-object) (view om-view)) ; (call-next-method) ; (when (or (null (om-get-bg-color view)) (equal :transparent (omcolor-c (om-get-bg-color view)))) ; (om-set-bg-color view (om-get-bg-color cont)) ; (mapc #'(lambda (v) (setf (vcontainer v) view)) (om-subviews view))))

Common Lisp

.lisp

cac-t-u-s/om-sharp

GPL-3.0

9/19/2024, 11:25:22 AM (Europe/Amsterdam)

191c21abefbbe2812251771cbfee7131fa997dd7dc8d7859ce7ff0365d2a6331

menu.lisp

cac-t-u-s_om-sharp/src/api/om-api-LW/menu.lisp

;========================================================================= ; OM API ; Multiplatform API for OpenMusic ; LispWorks Implementation ;========================================================================= ; ; This program 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. ; ; This program 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 this program. If not, see <http://www.gnu.org/licenses/>. ; ;========================================================================= ; Authors: J. Bresson, C. Agon ;========================================================================= ;;=========================================================================== ; MENUS AND POPUP MENUS ;;=========================================================================== (in-package :om-api) (export '( om-make-menu om-make-menu-comp om-make-menu-item om-set-menu-bar om-get-menu-bar om-pop-up-menu om-open-pop-up-menu om-get-menu-context om-popup-menu-context ) :om-api) (defun om-set-menu-bar (window menus) (capi::execute-with-interface window #'(lambda () (setf (capi::interface-menu-bar-items window) menus)) )) (defun om-get-menu-bar (window) (capi::interface-menu-bar-items window)) ;;; Inherits: title - items (defclass om-menu (capi::menu) ()) ;;; Inherits: items ;;; Allows selection (defclass om-menu-group (capi:menu-component) ()) ;;; Inherits: title - accelerator (defclass om-menu-item (capi::menu-item) ()) ;;;Creates a new menu with the given <title> and the list of <menus>. (defun om-make-menu (title items &key (enabled t)) (let ((enablefun (cond ((functionp enabled) #'(lambda (item) (declare (ignore item)) (funcall enabled))) ((and (symbolp enabled) (fboundp enabled)) #'(lambda (item) (declare (ignore item)) (funcall enabled))) (enabled #'(lambda (item) (declare (ignore item)) t)) (t #'(lambda (item) (declare (ignore item)) nil))))) (make-instance 'om-menu :title title :callback-type :none :items (list (om-make-menu-comp items :selection t)) :enabled-function enablefun ))) ;Creates a new leaf menu with the given <title> and <action>. (defun om-make-menu-item (title action &key (key nil) (key-mod :default) (enabled t) selected ) ;(print (list enabled selected)) (let ((enablefun (cond ((functionp enabled) #'(lambda (item) (declare (ignore item)) (funcall enabled))) ((and (symbolp enabled) (fboundp enabled)) #'(lambda (item) (declare (ignore item)) (funcall enabled))) (enabled #'(lambda (item) (declare (ignore item)) t)) (t #'(lambda (item) (declare (ignore item)) nil)))) (selectfun (cond ((functionp selected) #'(lambda (item) (declare (ignore item)) (funcall selected))) ((and (symbolp selected) (fboundp selected)) #'(lambda (item) (declare (ignore item)) (funcall selected))) (selected #'(lambda (item) (declare (ignore item)) t)) (t #'(lambda (item) (declare (ignore item)) nil))))) (make-instance 'om-menu-item :title title :accelerator (if (and enabled key) (concatenate 'string (cond ((equal key-mod :default) "accelerator-") (key-mod (concatenate 'string key-mod "-")) (t "")) key) nil) :enabled-function enablefun :callback-type :none :selected-function selectfun :callback action) )) (defmethod om-make-menu-comp ((items list) &key selection) (make-instance 'om-menu-group :items items :callback-type :item :interaction (if selection :multiple-selection :none))) (defmethod om-make-menu-comp ((items function) &key selection) (declare (ignore selection)) (make-instance 'om-menu-group :items-function items :callback-type :item :interaction :none)) ;;;;=================== ;;;; POP UP / CONTEXT MENU ;;;;=================== (defun list-to-menu (menu) (if (listp menu) (loop for elt in menu collect (if (listp elt) (make-instance 'capi:menu-component :items (list-to-menu elt) :interaction :multiple-selection) (list-to-menu elt) )) menu)) (defmethod om-get-menu-context ((self om-graphic-object)) nil) ;;; DEFAULT BEHAVIOR ;;; right click -> open menu context (defvar *menu-context-open* nil) (defmethod om-context-menu-callback ((self om-graphic-object) x y) ;;; cancel d&d init ;;; ;;; => why ? temporarily removed because it tended to raise other windows on right clicks.. ;(let ((win (capi::top-level-interface self))) ; (capi::find-interface (type-of win) :name (capi::capi-object-name win))) (om-activate-callback self t) (let* ((clicked (om-find-view-containing-point self (om-make-point x y))) (menu-list (om-get-menu-context clicked))) ;(om-view-click-handler clicked (om-convert-coordinates (om-make-point x y) self clicked)) (when menu-list (setf *menu-context-open* t) (om-open-pop-up-menu (capi::make-menu-for-pane self (list-to-menu menu-list)) self) (setf *menu-context-open* nil)) )) (defmethod om-popup-menu-context ((self om-graphic-object) &optional container-view) (let ((themenu (capi::make-menu-for-pane self (om-get-menu-context self)))) (om-open-pop-up-menu themenu self))) (defmethod om-popup-menu-context ((self t) &optional container-view) (let ((themenu (capi::make-menu-for-pane (om-get-menu-context self) self)) (container (if container-view container-view self))) (om-open-pop-up-menu themenu container))) ;;;========================= ;;; POP-UP AS AN OBJECT ;;; Explicit call for open ;;;========================= (defun om-open-pop-up-menu (themenu self) (capi::display-popup-menu themenu :owner self))

Common Lisp

.lisp

cac-t-u-s/om-sharp

GPL-3.0

9/19/2024, 11:25:22 AM (Europe/Amsterdam)

94d64cbeea81c8ff83c12799f22a933a7c7cb3fb17877ee60426cfebbcaf2887

transient-drawing.lisp

cac-t-u-s_om-sharp/src/api/om-api-LW/transient-drawing.lisp

;========================================================================= ; OM API ; Multiplatform API for OpenMusic ; LispWorks Implementation ;========================================================================= ; ; This program 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. ; ; This program 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 this program. If not, see <http://www.gnu.org/licenses/>. ; ;========================================================================= ; Authors: J. Bresson ;========================================================================= (in-package :om-api) (export '(om-transient-drawing-view om-start-transient-drawing om-start-transient-drawing-process om-stop-transient-drawing om-transient-drawing-active-p om-update-transient-drawing om-transient-drawing-item-clicked ; om-init-motion-click ;; only 1 of the 2 ! om-init-temp-graphics-motion ;; only 1 of the 2 ! ) :oa) (defclass om-transient-drawing-view (om-graphic-object) ((drawn-item :initform nil :accessor drawn-item) (drawing-process :initform nil :accessor drawing-process)) (:default-initargs :destroy-callback 'transient-drawing-view-destroy-calback)) (defmethod transient-drawing-view-destroy-calback ((self om-transient-drawing-view)) (om-stop-transient-drawing self) (om-destroy-callback self) ;;; does nothing.. ? ) (defmethod om-transient-drawing-active-p ((self om-transient-drawing-view)) (if (or (drawn-item self) (drawing-process self)) T NIL)) (defparameter *click-motion-view* nil) (defparameter *click-motion-action* nil) (defmethod om-transient-drawing-item-clicked ((self om-transient-drawing-view) clicked-pos-in-view) nil) (defmethod om-transient-drawing-item-double-clicked ((self om-transient-drawing-view) clicked-pos-in-view) nil) (defmethod om-clic-callback :around ((self om-transient-drawing-view) x y modifiers) (if (and (drawn-item self) (capi::over-pinboard-object-p (drawn-item self) x y)) (om-transient-drawing-item-clicked self (om-make-point x y)) ;; else: (call-next-method))) (defmethod om-multiple-clic-callback :around ((self om-transient-drawing-view) x y modifiers n) (if (and (drawn-item self) (capi::over-pinboard-object-p (drawn-item self) x y)) (om-view-doubleclick-handler self (om-make-point x y)) (call-next-method))) ;;;===================================== ;;; CURSORS AND OTHER MOVING DRAWINGS ;;; CHEAP VERSION BUT ACTIONS ARE LOCKED ;;;===================================== (defun start-transient-drawing-fun (view draw-fun position size &key display-mode) (loop ;;; this loop breaks when killed (capi:start-drawing-with-cached-display view #'(lambda (view x y w h) (declare (ignore x y w h)) (let ((user-info (capi:output-pane-cached-display-user-info view))) (when user-info (destructuring-bind (mode xx yy ww hh) user-info (declare (ignore mode)) (om-with-focused-view view (funcall draw-fun view (om-make-point xx yy) (om-make-point ww hh)))) ))) :user-info (list display-mode (om-point-x position) (om-point-y position) (om-point-x size) (om-point-y size)) :automatic-cancel nil :resize-automatic-cancel #'(lambda (pane) ;; will break the loop and restart (setf (capi:output-pane-cached-display-user-info pane) nil)) ) (loop ;;; this loop breaks when user-info is NIL (caused by a resize) (sleep 0.2) (when (not (capi:output-pane-cached-display-user-info view)) (return))) )) (defmethod om-start-transient-drawing-process ((self om-transient-drawing-view) draw-fun position size &key display-mode) (om-stop-transient-drawing self) (setf (drawing-process self) (mp:process-run-function (format nil "Animation for ~A" self) NIL 'start-transient-drawing-fun self draw-fun position size :display-mode display-mode))) (defmethod om-stop-transient-drawing-process ((self om-transient-drawing-view)) (when (drawing-process self) (capi:output-pane-free-cached-display self) (mp:process-kill (drawing-process self)) (setf (drawing-process self) nil) (om-invalidate-view self))) (defun update-transient-drawing-fun (view &key x y w h) (let ((user-info (capi:output-pane-cached-display-user-info view))) (when user-info (when x (setf (nth 1 user-info) x)) (when y (setf (nth 2 user-info) y)) (when w (setf (nth 3 user-info) (+ (nth 1 user-info) w))) (when h (setf (nth 4 user-info) (+ (nth 2 user-info) h))) (if (car user-info) (capi:update-drawing-with-cached-display-from-points view (nth 1 user-info) (nth 2 user-info) (nth 3 user-info) (nth 4 user-info) :extend (if (numberp (car user-info)) (car user-info) 1)) (capi:update-drawing-with-cached-display view)) ))) (defmethod om-update-transient-drawing-process ((self om-transient-drawing-view) &key x y w h) (when (and (drawing-process self) (not *click-motion-action*)) (capi::apply-in-pane-process self 'update-transient-drawing-fun self :x x :y y :w w :h h))) ;;;===================================== ;;; SAME USING A SIMPLE PINBOARD OBJECT ;;; MORE FLEXIBLE BUT MORE DRAWING ;;;===================================== (defmethod om-draw-contents-callback ((self om-transient-drawing-view) x y w h) (let ((item (drawn-item self))) (if item ;;; NO EFFECT (capi:with-geometry item (gp::with-graphics-state (self :mask (list (or x capi:%x%) (or y capi:%y%) (or w capi:%width%) (or h capi:%height%))) (call-next-method) (capi::draw-pinboard-object self item))) (call-next-method)))) (defmethod om-start-transient-drawing ((self om-transient-drawing-view) draw-fun position size &key display-mode) (declare (ignore display-mode)) (when (drawn-item self) (om-stop-transient-drawing self)) (setf (drawn-item self) (make-instance 'capi::drawn-pinboard-object :display-callback #'(lambda (pane obj x y w h) (declare (ignore obj)) (when (and x y w h) (om-with-focused-view pane (funcall draw-fun pane (om-make-point x y) (om-make-point w h))))) :x (om-point-x position) :y (om-point-y position) :visible-min-width (om-point-x size) :visible-min-height (om-point-y size) )) (capi:apply-in-pane-process self 'capi:manipulate-pinboard self (drawn-item self) :add-top) ) (defmethod om-stop-transient-drawing ((self om-transient-drawing-view)) ;;; (ignore-errors (om-stop-transient-drawing-process self) (when (drawn-item self) (capi::apply-in-pane-process self 'capi:manipulate-pinboard self (drawn-item self) :delete) (om-invalidate-view self) (setf (drawn-item self) nil) ))) (defmethod om-update-transient-drawing ((self om-transient-drawing-view) &key x y w h) ;;; => drawing process not used (om-update-transient-drawing-process self :x x :y y :w w :h h) (when (drawn-item self) (capi::apply-in-pane-process self #'(lambda () (when (drawn-item self) (capi:with-geometry (drawn-item self) (when (or x y) (setf (capi:pinboard-pane-position (drawn-item self)) (values (or x capi:%x% 0) (or y capi:%y% 0)))) (when (or w h) (setf (capi:pinboard-pane-size (drawn-item self)) (values (or w capi:%width% 0) (or h capi:%height% 0)))) ) ;; (capi::redraw-pinboard-object (drawn-item self)) ))) ;; return something if drawn-item was not null (drawn-item self))) ;;;===================== ;;; CLICK-AND-DRAG GRAPHICS ;;;===================== ;;; views handling movable graphics must be subclasses of handle-temp-graphics (defclass handle-click-motion () ((container-view :initform nil :accessor container-view) (init-pos :initform nil :accessor init-pos) (temp-graphics :initform nil :accessor temp-graphics) (motion-fun :initform nil :accessor motion-fun) (release-fun :initform nil :accessor release-fun) (active :initform nil :accessor active) (min-move :initform 0 :accessor min-move))) (defparameter *global-motion-handler* nil) (defun init-motion-handler () (or *global-motion-handler* (setf *global-motion-handler* (make-instance 'handle-click-motion)))) ;;; initites the handling of a movable graphics (defmethod om-init-temp-graphics-motion ((self om-graphic-object) pos graphics &key motion release (min-move 0)) (init-motion-handler) (when (and (temp-graphics *global-motion-handler*) (om-view-container (temp-graphics *global-motion-handler*))) (om-remove-subviews (om-view-container (temp-graphics *global-motion-handler*)) (temp-graphics *global-motion-handler*))) (setf (container-view *global-motion-handler*) self (init-pos *global-motion-handler*) pos (min-move *global-motion-handler*) min-move (temp-graphics *global-motion-handler*) graphics (motion-fun *global-motion-handler*) motion (release-fun *global-motion-handler*) release) (when (null (min-move *global-motion-handler*)) ;; if min-move is null the motion is considered active straight away (setf (active *global-motion-handler*) t) (when (temp-graphics *global-motion-handler*) (om-add-subviews (container-view *global-motion-handler*) (temp-graphics *global-motion-handler*)))) t) (defmethod default-motion-action ((self t) position) nil) (defun handle-temp-graphics-motion (sender pos) (when (and *global-motion-handler* (container-view *global-motion-handler*)) (let ((position (om-convert-coordinates pos sender (container-view *global-motion-handler*)))) (unless (om-points-equal-p (init-pos *global-motion-handler*) position) (unless (active *global-motion-handler*) (when (or (null (min-move *global-motion-handler*)) (>= (abs (- (om-point-x position) (om-point-x (init-pos *global-motion-handler*)))) (min-move *global-motion-handler*)) (>= (abs (- (om-point-y position) (om-point-y (init-pos *global-motion-handler*)))) (min-move *global-motion-handler*))) (when (temp-graphics *global-motion-handler*) (om-add-subviews (container-view *global-motion-handler*) (temp-graphics *global-motion-handler*))) (setf (active *global-motion-handler*) t) )) (when (active *global-motion-handler*) (default-motion-action (temp-graphics *global-motion-handler*) position) (when (motion-fun *global-motion-handler*) (funcall (motion-fun *global-motion-handler*) (container-view *global-motion-handler*) position)) ) )))) (defmethod restore-drawable-view ((self t)) nil) (defmethod restore-drawable-view ((self om-transient-drawing-view)) (when (drawn-item self) (capi:manipulate-pinboard self (drawn-item self) :delete) (capi:manipulate-pinboard self (drawn-item self) :add-top) )) (defun handle-temp-graphics-release (sender pos) (when (and *global-motion-handler* (container-view *global-motion-handler*)) (let ((position (om-convert-coordinates pos sender (container-view *global-motion-handler*)))) (when (and (or (null (min-move *global-motion-handler*)) (not (om-points-equal-p (init-pos *global-motion-handler*) position))) (active *global-motion-handler*) (release-fun *global-motion-handler*)) (funcall (release-fun *global-motion-handler*) (container-view *global-motion-handler*) position)) (when (temp-graphics *global-motion-handler*) (om-remove-subviews (container-view *global-motion-handler*) (temp-graphics *global-motion-handler*))) (restore-drawable-view (container-view *global-motion-handler*)) (setf (temp-graphics *global-motion-handler*) nil (motion-fun *global-motion-handler*) nil (release-fun *global-motion-handler*) nil (active *global-motion-handler*) nil (init-pos *global-motion-handler*) pos (min-move *global-motion-handler*) 0 (container-view *global-motion-handler*) nil) ))) ;;; for click&drag actions (defmethod om-click-motion-handler :after ((self om-graphic-object) pos) (handle-temp-graphics-motion self pos)) ;(defmethod om-click-motion-handler :after ((self om-graphic-object) pos) nil) (defmethod om-click-release-handler :after ((self om-graphic-object) pos) (handle-temp-graphics-release self pos)) #| ;;;===================================== ;;; CLICK-AND-DRAG DRAWING ;;;===================================== ;;; typically called in a click-handler (defmethod om-init-motion-click ((self om-graphic-object) position &key motion-draw draw-pane motion-action release-action display-mode) ;(print (list "start" self)) (setf *click-motion-view* self) (setf *click-motion-action* t) (when (or motion-action release-action) (setf (temp-data self) (list motion-action release-action (om-point-x position) (om-point-y position) (om-point-x position) (om-point-y position) draw-pane))) (when motion-draw (setf (capi:output-pane-cached-display-user-info self) nil) ;;; will break the animation loop if any (start-transient-click-drawing (or draw-pane self) motion-draw (if draw-pane (om-convert-coordinates position self draw-pane) position) display-mode)) t) (defmethod start-transient-click-drawing ((self om-view) motion-draw position display-mode) ;(capi:output-pane-free-cached-display self) (capi::apply-in-pane-process self 'capi:start-drawing-with-cached-display self #'(lambda (view x y w h) (let ((dragging-info (capi:output-pane-cached-display-user-info view))) (when dragging-info (destructuring-bind (mode x1 y1 x2 y2) dragging-info (om-with-focused-view view (funcall motion-draw view (om-make-point x1 y1) (om-make-point x2 y2))))))) :user-info (list display-mode (om-point-x position) (om-point-y position) (om-point-x position) (om-point-y position)) ;:automatic-cancel nil )) (defmethod om-click-motion-handler :around ((self om-graphic-object) position) ;(print (list self position *click-motion-view*)) (if *click-motion-action* (let* ((view *click-motion-view*) (motion-info (temp-data view)) (x (om-point-x position)) (y (om-point-y position)) (pane view)) (when motion-info (destructuring-bind (motion-action release-action x0 y0 old-x old-y draw-pane) motion-info (unless (and (= old-x x) (= old-y y)) (when motion-action (capi::apply-in-pane-process (om-get-view view) motion-action view position (om-make-point old-x old-y))) (setf (nth 4 (temp-data view)) x (nth 5 (temp-data view)) y)) (when draw-pane (let ((pp (om-convert-coordinates position self draw-pane))) (setf pane draw-pane x (om-point-x pp) y (om-point-y pp)))) )) (let ((dragging-info (capi:output-pane-cached-display-user-info pane))) (when dragging-info (destructuring-bind (mode x0 y0 old-x old-y) dragging-info (unless (and (= old-x x) (= old-y y)) (if mode (capi::apply-in-pane-process (om-get-view view) 'capi:update-drawing-with-cached-display-from-points pane x0 y0 x y :extend (if (numberp mode) mode 0)) (capi::apply-in-pane-process (om-get-view view) 'capi:update-drawing-with-cached-display pane)) (setf (nth 3 dragging-info) x (nth 4 dragging-info) y)) )))) (call-next-method))) (defmethod om-click-release-handler :after ((self om-graphic-object) pos) (declare (ignore pos)) ;(print (list self *click-motion-action* *click-motion-view*)) (when *click-motion-action* ; (equal *click-motion-view* self) (let* ((view *click-motion-view*) (motion-info (temp-data view))) (setf *click-motion-action* nil) (when motion-info (destructuring-bind (motion-action release-action x0 y0 old-x old-y draw-pane) motion-info (let ((dragging-info (capi:output-pane-free-cached-display (or draw-pane view)))) ;; nothing more to do... (setf (capi:output-pane-cached-display-user-info (or draw-pane view)) nil)) (when release-action (capi::apply-in-pane-process (om-get-view view) release-action view (om-make-point x0 y0) (om-convert-coordinates pos self view)) ))) ;(setf *click-motion-action* nil) (setf (temp-data view) nil)))) |#

Common Lisp

.lisp

cac-t-u-s/om-sharp

GPL-3.0

9/19/2024, 11:25:22 AM (Europe/Amsterdam)

327e86a3205c42549db47cf242d040b1c9bff243229edca6e1bf5cc55351b133

item-tree.lisp

cac-t-u-s_om-sharp/src/api/om-api-LW/item-tree.lisp

;========================================================================= ; OM API ; Multiplatform API for OpenMusic ; LispWorks Implementation ;========================================================================= ; ; This program 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. ; ; This program 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 this program. If not, see <http://www.gnu.org/licenses/>. ; ;========================================================================= ; Authors: J. Bresson, C. Agon ;========================================================================= (in-package :om-api) (export '(om-make-tree-view om-double-clicked-item-from-tree-view om-selected-item-from-tree-view) :om-api) ;;; the capi::extended-selection-tree-view may be better (?) ;;; but the simple one looks better... (defclass om-item-tree (om-graphic-object capi:tree-view) ()) (defun om-make-tree-view (base-items &key expand-item position size bg-color item-icon icons print-item font) (declare (ignore position)) ;;; for the moment (but in general this is positioned in a layout) (let ((ilist (when icons (make-instance 'capi:image-list :image-sets icons :image-width 16 :image-height 16)))) (make-instance 'om-item-tree :visible-min-width (and size (om-point-x size)) :visible-min-height (and size (om-point-y size)) :roots base-items :children-function expand-item :background (omcolor-c bg-color) :retain-expanded-nodes t :font font :accepts-focus-p nil ;:image-width 16 :checkbox-status nil :image-lists (list :normal ilist) :image-function (cond ((or (functionp item-icon) (and (symbolp item-icon) (fboundp item-icon))) (if icons #'(lambda (item) (position (funcall item-icon item) icons)) item-icon)) ((null item-icon) item-icon) (t #'(lambda (item) (declare (ignore item)) item-icon))) :callback-type :interface-data :print-function (or print-item #'(lambda (x) (format nil "~a" x ))) :selection-callback #'tree-view-selected-function :retract-callback #'tree-view-unselected-function :action-callback #'tree-view-action-function ;:extend-callback #'(lambda (self item) (add-a-message self "~&Extended item ~S" item)) ;:retract-callback #'(lambda (self item) (add-a-message self "~&Retracted item ~S" item)) ;:delete-item-callback 'test-extend-tree-view-delete-callback ;:pane-menu 'extend-tree-view-test-menu ))) (defmethod om-double-clicked-item-from-tree-view (item window) nil) (defun tree-view-action-function (window item) (om-double-clicked-item-from-tree-view item window)) (defmethod om-selected-item-from-tree-view (item window) nil) (defun tree-view-selected-function (window item) (om-selected-item-from-tree-view item window)) (defun tree-view-unselected-function (window item) (om-selected-item-from-tree-view nil window)) ;(print (list self item)) ;(with-slots (tree) self ; (capi:tree-view-update-item tree item t)) ;(add-a-message self "~&Action item ~S" item) #| ;;; FROM LW: ;;; The undocumented interface in 6.0 for :delete-item-callback ;;; changed in 6.1, and this code show a way of coding ;;; to cope with both interfaces. It works because the items ;;; themselves are not never lists in this example. (defun add-a-message (interface format-string &rest args) (let* ((message-pane (slot-value interface 'message-pane)) (stream (capi:collector-pane-stream message-pane))) (apply 'format stream format-string args))) (defun test-extend-tree-view-delete-callback (tree item) (if (listp item) ;; true since 6.1, false until 6.0 (progn (setq *extend-tree-view-test-deleted-items* (union *extend-tree-view-test-deleted-items* item)) (capi:with-atomic-redisplay (tree) (dolist (i-item item) (capi:tree-view-update-item tree i-item t)))) (progn (pushnew item *extend-tree-view-test-deleted-items*) (capi:tree-view-update-item tree item t)))) (defun extend-tree-view-test-menu (self data x y) (declare (ignorable data x y)) (in-extend-tree-view-test-menu (capi:top-level-interface self))) (capi:define-menu in-extend-tree-view-test-menu (self) :menu (("Delete" :callback #'(lambda (interface) (with-slots (tree) interface (test-extend-tree-view-delete-callback tree (capi:choice-selected-items tree)))) :enabled-function #'(lambda (interface) (with-slots (tree) interface (capi:choice-selection tree)))) (:component (("Undelete all" :callback #'(lambda(interface) (setq *extend-tree-view-test-deleted-items* nil) (with-slots (tree) interface ;;redo the tree (setf (capi:tree-view-roots tree) (capi:tree-view-roots tree)))))))) :callback-type :interface) |#

Common Lisp

.lisp

cac-t-u-s/om-sharp

GPL-3.0

9/19/2024, 11:25:22 AM (Europe/Amsterdam)

62c9cbeb9f121f7ee25694d8c7fe7c35593cec6c61692cda9c98eae52ee6461b

files.lisp

cac-t-u-s_om-sharp/src/api/om-api-LW/files.lisp

;========================================================================= ; OM API ; Multiplatform API for OpenMusic ; LispWorks Implementation ;========================================================================= ; ; This program 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. ; ; This program 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 this program. If not, see <http://www.gnu.org/licenses/>. ; ;========================================================================= ; Authors: J. Bresson, C. Agon ;========================================================================= ;=========================================================================== ; FILE UTILITIES ;=========================================================================== (in-package :om-api) (export '( om-compiled-type om-make-pathname om-pathname-location om-directory-pathname-p om-directory om-lisp-image om-user-home om-user-pref-folder om-create-file om-create-directory om-copy-file om-copy-directory om-delete-file om-delete-directory om-read-line om-clean-line om-stream-eof-p ) :om-api) ;;;================== ;;; PATHNAME MANAGEMENT (create, copy, delete...) ;;;================== (defparameter *compiled-type* (pathname-type (cl-user::compile-file-pathname ""))) ;;; NOT WORK IN STANDALONE ! (defun om-compiled-type () (if (om-standalone-p) *compiled-type* (pathname-type (cl-user::compile-file-pathname "")))) ;; handles device, host, etc. ;; dircetory is a pathname (defun om-make-pathname (&key directory name type host device) #-mswindows(declare (ignore host)) (make-pathname #+mswindows :host #+mswindows (or host (and directory (pathnamep directory) (pathname-host directory))) :device (or device (and directory (pathnamep directory) (pathname-device directory))) :directory (if (or (stringp directory) (pathnamep directory)) (pathname-directory directory) directory) :name name :type type)) (defun om-pathname-location (path) (lw::pathname-location path)) (defun om-directory-pathname-p (p) (system::directory-pathname-p p)) (defun om-directory (path &key (type nil) (directories nil) (files t) (resolve-aliases nil) (hidden-files nil) (recursive nil)) (when path (let ((rep (ignore-errors (directory (namestring path) :link-transparency resolve-aliases)))) (when rep (when (not files) (setf rep (remove-if-not 'om-directory-pathname-p rep))) (when (not directories) (setf rep (remove-if 'om-directory-pathname-p rep))) (when (not hidden-files) (setf rep (remove-if #'(lambda (item) (or (and (om-directory-pathname-p item) (string-equal (subseq (car (last (pathname-directory item))) 0 1) ".")) (and (stringp (pathname-name item)) (> (length (pathname-name item)) 0) (string-equal (subseq (pathname-name item) 0 1) ".")))) rep))) (when type (cond ((stringp type) (setf rep (loop for item in rep when (or (om-directory-pathname-p item) (string-equal (pathname-type item) type)) collect item))) ((consp type) (setf rep (loop for item in rep when (or (om-directory-pathname-p item) (member (pathname-type item) type :test 'string-equal)) collect item))) (t nil))) (if recursive (append rep (loop for dir in (om-directory path :directories t :files nil :resolve-aliases nil :hidden-files hidden-files :recursive nil) append (om-directory dir :type type :directories directories :files files :resolve-aliases resolve-aliases :hidden-files hidden-files :recursive t)) ) rep))))) ;;;================== ;;; SPECIAL LOCATIONS ;;;================== (defun om-lisp-image () (lw::lisp-image-name)) (defun om-user-home () (USER-HOMEDIR-PATHNAME)) (defun om-user-pref-folder () (let* ((userhome (om-user-home))) (make-pathname :host (pathname-host userhome) :device (pathname-device userhome) :directory #+cocoa(append (pathname-directory userhome) (list "Library" "Preferences")) #+win32(append (pathname-directory userhome) (list "Application Data")) #+linux(append (pathname-directory userhome) (list ".local" "share")) ))) ;;;================== ;;; FILE/FOLDER MANAGEMENT (create, copy, delete...) ;;;================== (defun om-create-file (pathname) (with-open-file (file pathname :direction :output :if-does-not-exist :create) (declare (ignore file)))) (defun om-create-directory (pathname &key (replace-if-exists nil)) (let ((p (pathname pathname))) (when (and (probe-file p) replace-if-exists) (om-delete-directory p)) (lw::ENSURE-DIRECTORIES-EXIST p) p)) (defun om-copy-file (sourcepath targetpath &key (replace-if-exists t)) (handler-bind ((error #'(lambda (err) (capi::display-message "An error of type ~a occurred: ~a" (type-of err) (format nil "~A" err)) (abort err)))) (when (and (probe-file targetpath) replace-if-exists) (delete-file targetpath)) (system::copy-file sourcepath targetpath) targetpath)) (defun om-copy-directory (sourcedir targetpath) (system::call-system (concatenate 'string "cp -R \"" (namestring sourcedir) "\" \"" (namestring targetpath) "\""))) (defun om-delete-file (name) (when (and name (probe-file name)) (delete-file name :no-error))) (defun om-delete-directory (path) (if (system::directory-pathname-p path) (let ((directories (om-directory path :directories t :files t))) (loop for item in directories do (om-delete-directory item)) (delete-directory path :no-error) t) (delete-file path :no-error))) ;;;================== ;;; I/O STREAMS ;;;================== (defun om-read-line (file) (read-line file nil 'eof)) ; removes wrong characters at the end (defun om-clean-line (line) (if (stringp line) (if (> (length line) 0) (let ((lastchar (elt line (- (length line) 1)))) (if (or (equal lastchar #\Space) (equal lastchar #\LineFeed)) (om-clean-line (subseq line 0 (- (length line) 1))) line)) line) line)) (defun om-stream-eof-p (s) ;(stream::stream-check-eof-no-hang s) (let ((c (read-char s nil 'eof))) (unless (equal c 'eof) (unread-char c s)) (equal c 'eof)))

Common Lisp

.lisp

cac-t-u-s/om-sharp

GPL-3.0

9/19/2024, 11:25:22 AM (Europe/Amsterdam)

857625510dfeb90601c8a79a89e3013d0c0c247f702fc5855ebb03ae4ea4b718

system.lisp

cac-t-u-s_om-sharp/src/api/om-api-LW/system.lisp

;========================================================================= ; OM API ; Multiplatform API for OpenMusic ; LispWorks Implementation ;========================================================================= ; ; This program 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. ; ; This program 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 this program. If not, see <http://www.gnu.org/licenses/>. ; ;========================================================================= ; Authors: J. Bresson, C. Agon ;========================================================================= ;=========================================================================== ; GENERAL SYSTEM UTILITIES ;=========================================================================== (in-package :om-api) ;;;=================== ;;; export : ;;;=================== (export '( om-quit om-standalone-p om-gc om-get-user-name om-get-date om-error-handle-funcall om-with-error-handle om-trap-errors om-with-redefinitions om-ignore&print-error om-set-clipboard om-get-clipboard om-open-in-browser ) :om-api) (defparameter *lw-version* (read-from-string (subseq (lisp-implementation-version) 0 1))) (defun om-standalone-p () (if (member :om-deliver *features*) t nil)) (defun om-quit () (when t ; (member :om-deliver *features*) (quit :confirm nil :ignore-errors-p t))) (defun om-get-user-name () (system::get-user-name)) (defun om-get-date (&optional (with-hour t)) (let ((date-string (sys::date-string))) (if with-hour date-string (subseq date-string 0 10) ))) ;;;==================== ;;; MEMORY ;;;==================== ;;; :error :warn nil (setf system::*stack-overflow-behaviour* :warn) ;(hcl::current-stack-length) ;(hcl:extend-current-stack 50) (defun om-gc () (system::gc-all)) ;;;==================== ;;; ERROR MANAGEMENT ;;;==================== (defun om-error-handle-funcall (func) (handler-bind ((error #'(lambda (err) (capi::display-message "An error of type ~a occurred: ~%\"~a\"" (type-of err) (format nil "~A" err)) (abort err)))) (funcall func))) (defmacro om-with-error-handle (&body body) `(if (om-standalone-p) (handler-bind ((error #'(lambda (err) (capi::display-message "An error of type ~a occurred: ~%\"~a\"" (type-of err) (format nil "~A" err)) (abort err)))) ,@body) (progn ,@body))) (defmacro om-with-redefinitions (&body body) `(let ((lispworks::*HANDLE-WARN-ON-REDEFINITION* nil)) ,@body)) (defmacro om-ignore&print-error (&rest body) `(multiple-value-bind (a b) (ignore-errors ,@body) (when b (print (format nil "Error: ~A" b))) a)) (defun om-error-handler (&rest l) (let ((err (car l)) (backtrace (with-output-to-string (stream) (dbg:output-backtrace t stream)))) (capi::display-message "ERROR: ~A~%" err) (setf om-lisp::*error-backtrace* (print (format nil "ERROR: ~A~%~%~A" err backtrace))) (abort))) (defun om-trap-error-handler (condition) (format *error-output* "ERROR: ~A~&" condition) (throw 'trap-errors nil)) (defmacro om-trap-errors (&rest forms) `(catch 'trap-errors (handler-bind ((error #'om-trap-error-handler)) ,@forms))) (defun set-om-debugger () (setq *debugger-hook* 'om-error-handler)) (define-action "When starting image" "Init debug/backtrace tool" 'set-om-debugger) ;;;==================== ;;; CLIPBOARD ;;;==================== (defun om-set-clipboard (value) (capi::set-clipboard (om-front-window) value)) (defun om-get-clipboard () (capi::clipboard (om-front-window))) ;;;==================== ;;; WEB ;;;==================== (defun om-open-in-browser (url) (sys::open-url url)) #| ;;; test: trying to access remote file contents via HTTP ;;; not working very well so far... (defun test-http () (with-open-stream (http (comm:open-tcp-stream "www.lispworks.com" ;""https://github.com/cac-t-u-s/om-sharp/blob/master/README.md"" 80 :errorp t)) (format http "GET / HTTP/1.0~C~C~C~C" (code-char 13) (code-char 10) (code-char 13) (code-char 10)) (force-output http) (write-string "Waiting to reply...") (loop for line = (read-line http nil nil); while line do (write-line line)) ) ) |#

Common Lisp

.lisp

cac-t-u-s/om-sharp

GPL-3.0

9/19/2024, 11:25:22 AM (Europe/Amsterdam)

e245091d7028cb47178e43ea2a9bd723f82f02a3e238ae09c0aba11475a56e9c

user-interface.lisp

cac-t-u-s_om-sharp/src/api/om-api-LW/user-interface.lisp

;========================================================================= ; OM API ; Multiplatform API for OpenMusic ; LispWorks Implementation ;========================================================================= ; ; This program 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. ; ; This program 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 this program. If not, see <http://www.gnu.org/licenses/>. ; ;========================================================================= ; Authors: J. Bresson, C. Agon ;========================================================================= ;;=========================================================================== ; PREDEFINED DIALOGS AND MESSAGES ;;=========================================================================== (in-package :om-api) ;;;========== ;;; export : ;;;========== (export '( om-get-user-string om-choose-directory-dialog om-choose-new-directory-dialog om-choose-file-dialog om-choose-new-file-dialog om-y-or-n-dialog om-y-n-cancel-dialog om-choose-color-dialog om-pick-color-view om-choose-font-dialog om-message-dialog om-beep ) :om-api) ;;;========== (defvar *last-directory* nil) (defun def-dialog-owner () #-cocoa nil #+cocoa (capi::convert-to-screen)) (defun om-get-user-string (prompt &key (initial-string "")) (capi::prompt-for-string prompt :initial-value initial-string :pane-args `(:visible-min-width ,(max 300 (om-string-size initial-string (om-def-font :large)))) :accept-null-string t)) ;;; prompt does not work (macOS 10.14) ? (defun om-choose-file-dialog (&key (prompt "Choose a File") (directory nil) (types nil)) (let ((rep (capi::prompt-for-file prompt :filters types :filter (if types (cadr types)) :owner (def-dialog-owner) :pathname (or directory *last-directory*)))) (when rep (setf *last-directory* (make-pathname :directory (pathname-directory rep)))) rep)) ;(defmacro om-with-file-dialog-process ((file &key (prompt "Choose a File") (directory nil) (button-string "OK") (types nil)) ; &body body) ; `(capi:with-dialog-results (,file ok-p) ; (capi::prompt-for-file ,prompt ;:filters ',types :filter (if ',types (cadr ',types)) ; :owner ,(def-dialog-owner) ; :pathname ,(or directory *last-directory*)) ; (when ,file ; (setf *last-directory* (make-pathname :directory (pathname-directory ,file)))) ; ,@body)) (defun om-choose-new-file-dialog (&key (prompt "Choose a new file") (directory nil) (name "") (types nil)) (let* ((dir (or directory *last-directory*)) (rep (capi::prompt-for-file prompt :filters types :filter (if types (cadr types)) :owner (def-dialog-owner) :pathname (make-pathname :directory (when dir (pathname-directory dir)) :name name) :operation :save))) (when rep (setf *last-directory* (make-pathname :directory (pathname-directory rep)))) rep)) (defun om-choose-directory-dialog (&key (prompt "Choose a directory") (directory nil)) (let ((rep (capi::prompt-for-directory prompt :owner (def-dialog-owner) :pathname (or directory *last-directory*)))) (when rep (setf *last-directory* (make-pathname :directory (pathname-directory rep)))) rep)) (defun om-choose-new-directory-dialog (&key (prompt "Choose location and name for the new directory") (directory nil) (defname nil)) (let* ((dir (or directory *last-directory*)) (def (if dir (make-pathname :directory (pathname-directory dir) :name defname) defname)) (path (capi::prompt-for-file prompt :owner (def-dialog-owner) :filter nil :filters nil :pathname def :operation :save))) (when path (setf *last-directory* (make-pathname :directory (pathname-directory path))) (make-pathname :device (pathname-device path) :directory (append (pathname-directory path) (list (pathname-name path)))) ))) (defun om-y-or-n-dialog (message &key (default nil)) (capi::prompt-for-confirmation message :default-button (if (equal default :yes) :ok nil))) (defun om-y-n-cancel-dialog (message &key (default nil)) (multiple-value-bind (answer successp) (capi:prompt-for-confirmation message :cancel-button t :default-button (if (equal default :yes) :ok nil)) (if successp answer :cancel))) ;;; USED IN THE MAC (defclass om-pick-color-view (om-view) ((color :accessor color :initarg :color :initform (om-make-color 0 0 0)) (after-fun :accessor after-fun :initform nil :initarg :after-fun))) (defmethod om-draw-contents ((self om-pick-color-view)) (om-draw-rect 0 0 (om-width self) (om-height self) :fill nil :color (om-def-color :gray)) (when (= 0 (om-color-a (color self))) (om-draw-line 0 0 (om-width self) (om-height self) :color (om-def-color :gray)) (om-draw-line 0 (om-height self) (om-width self) 0 :color (om-def-color :gray)) )) (defmethod set-color ((self om-pick-color-view) (color omcolor)) (om-set-bg-color self color) (setf (color self) color) (when (after-fun self) (funcall (after-fun self) self))) (defmethod om-view-click-handler ((self om-pick-color-view) pos) (declare (ignore pos)) (let ((color (om-make-color-alpha (make-omcolor :c (capi::prompt-for-color "Color Chooser" :color (omcolor-c (color self)))) (om-color-a (color self))))) (set-color self color))) #+cocoa (defun om-choose-color-dialog (&key color alpha owner) (let* ((win (om-make-window 'om-dialog ;:size (om-make-point 240 110) :resize nil :window-title "Choose a New Color..." :win-layout 'om-row-layout)) (col (or color (om-def-color :black))) (coloritem (om-make-view 'om-pick-color-view :position (om-make-point 40 20) :size (om-make-point 60 60) :color col :bg-color col))) (om-add-subviews win (if alpha (om-make-layout 'om-row-layout :subviews (list coloritem (om-make-di 'om-slider :direction :vertical ;; does not work... ? :range '(0 255) :value (round (* (om-color-a (color coloritem)) 255)) :size (omp 30 nil) :di-action #'(lambda (item) (let ((newcolor (make-omcolor :c (color::color-with-alpha (omcolor-c (color coloritem)) (/ (om-slider-value item) 255.0))))) (set-color coloritem newcolor) )) ))) coloritem) (om-make-layout 'om-column-layout :subviews (list (om-make-di 'om-button :position (om-make-point 130 26) :size (om-make-point 80 24) :text "Cancel" :di-action #'(lambda (item) (declare (ignore item)) (om-return-from-modal-dialog win nil))) (om-make-di 'om-button :position (om-make-point 130 58) :size (om-make-point 80 24) :text "OK" :focus t :default t :di-action #'(lambda (item) (declare (ignore item)) (om-return-from-modal-dialog win (color coloritem))))) )) (om-modal-dialog win owner))) #-cocoa (defun om-choose-color-dialog (&key color alpha owner) (let ((rep (capi::prompt-for-color "Choose a color" :color (when color (omcolor-c color)) :owner owner))) (when rep (make-omcolor :c rep)))) ; (om-choose-color-dialog) (defun om-message-dialog (message) (capi::display-message message)) (defun om-beep () (capi::beep-pane nil)) (defun om-choose-font-dialog (&key (font (om-def-font :large))) (let ((font (capi::prompt-for-font "Choose a font" :font font :owner nil))) (and font (gp::font-description font))))

Common Lisp

.lisp

cac-t-u-s/om-sharp

GPL-3.0

9/19/2024, 11:25:22 AM (Europe/Amsterdam)

0cfef2582db247de9bd30f155bf8ca98a9dfb93a608f0c84e818bcf8e9840a55

layout.lisp

cac-t-u-s_om-sharp/src/api/om-api-LW/layout.lisp

;========================================================================= ; OM API ; Multiplatform API for OpenMusic ; LispWorks Implementation ;========================================================================= ; ; This program 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. ; ; This program 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 this program. If not, see <http://www.gnu.org/licenses/>. ; ;========================================================================= ; Author: J. Bresson ;========================================================================= (export '( om-abstract-layout om-simple-layout om-column-layout om-row-layout om-grid-layout om-draw-layout om-make-layout om-get-current-view om-set-current-view om-tab-layout om-set-layout-ratios om-update-layout ) :oa) (in-package :oa) (defclass om-abstract-layout (om-graphic-object) ()) (defclass om-simple-layout (om-abstract-layout om-interactive-object capi::simple-pinboard-layout) () (:default-initargs :background #+cocoa :transparent #-cocoa :background)) (defclass om-tab-layout (om-abstract-layout capi::tab-layout) ()) (defclass om-column-layout (om-abstract-layout capi::column-layout) ()) (defclass om-row-layout (om-abstract-layout capi::row-layout) ()) (defclass om-grid-layout (om-abstract-layout capi::grid-layout) ()) ;;; a layout subview can be a string, a list (string font), or another item ;;; the only case to handle with LW is the translation of (string font) (defun layout-view-process (item) (if (and (listp item) (stringp (car item))) (list :title (car item) :title-font (cadr item) :title-args '(:visible-min-height 20)) item)) (defun make-xy-args (class arg val) (if (subtypep class 'om-grid-layout) (let ((x-arg (intern (concatenate 'string "X-" (string-upcase arg)) :keyword)) (y-arg (intern (concatenate 'string "Y-" (string-upcase arg)) :keyword)) (valval (if (listp val) val (list val val)))) (list x-arg (car valval) y-arg (cadr valval))) (list arg val))) (defun om-make-layout (class &rest other-args &key subviews ratios delta dimensions align name position size bg-color scrollbars (selection 0) &allow-other-keys) (let ((ll (if (subtypep class 'om-tab-layout) (make-instance class :accepts-focus-p t :items subviews :name name :print-function #'(lambda (pane) (or (capi::capi-object-name pane) "Untitled Tab")) :visible-child-function 'identity :selected-item (nth selection subviews)) (apply 'make-instance (append (list class :name name ;;:automatic-resize '(:width-ratio 1.0 :height-ratio 1.0) :description (mapcar 'layout-view-process subviews) :has-title-column-p nil :allow-other-keys t :horizontal-scroll (or (equal scrollbars t) (equal scrollbars :h)) ;;; will work only if inside a simple-layout :vertical-scroll (or (equal scrollbars t) (equal scrollbars :v))) (make-xy-args class :uniform-size-p nil) (when ratios (make-xy-args class :ratios ratios)) (when delta (make-xy-args class :gap delta)) (when align (make-xy-args class :adjust align)) ;;; APPARENTLY ADJUST DOES NOT WORK... (when dimensions (list :columns (if (listp dimensions) (car dimensions) dimensions) :rows (if (listp dimensions) (cadr dimensions) dimensions))) (when position (list :default-x (om-point-x position) :default-y (om-point-y position))) (when size (list :default-width (om-point-x size) :default-height (om-point-y size))) other-args ))))) (when bg-color (om-set-bg-color ll bg-color)) ll)) (defmethod om-set-layout-ratios ((self om-abstract-layout) ratio-list) nil) (defmethod om-set-layout-ratios ((self om-column-layout) ratio-list) (setf (capi::layout-ratios self) ratio-list)) (defmethod om-set-layout-ratios ((self om-row-layout) ratio-list) (setf (capi::layout-ratios self) ratio-list)) (defmethod om-set-layout-ratios ((self om-grid-layout) ratio-list) (if (and (listp ratio-list) (listp (car ratio-list))) (setf (capi::layout-x-ratios self) (car ratio-list) (capi::layout-y-ratios self) (cadr ratio-list)) (setf (capi::layout-x-ratios self) ratio-list (capi::layout-y-ratios self) ratio-list))) (defmethod om-update-layout ((self om-column-layout)) (capi:apply-in-pane-process self #'(lambda () (setf (capi::layout-ratios self) (capi::layout-ratios self))))) (defmethod om-update-layout ((self om-row-layout)) (capi:apply-in-pane-process self #'(lambda () (setf (capi::layout-ratios self) (capi::layout-ratios self))))) (defmethod om-update-layout ((self om-grid-layout)) (capi:apply-in-pane-process self #'(lambda () (setf (capi::layout-x-ratios self) (capi::layout-y-ratios self) (capi::layout-y-ratios self) (capi::layout-y-ratios self))))) (defmethod om-update-layout ((self om-abstract-window)) (mapc 'om-update-layout (om-subviews self))) (defmethod om-view-parent ((self om-abstract-layout)) (capi::element-parent self)) (defmethod om-subviews ((self om-abstract-layout)) (capi:layout-description self)) (defmethod om-add-subviews ((self om-abstract-layout) &rest subviews) (capi::apply-in-pane-process self #'(lambda (layout views) (setf (capi::layout-description layout) (append (capi::layout-description layout) views)) (when (car (last subviews)) (capi::set-pane-focus (car (last subviews)))) ) self subviews)) (defmethod om-remove-subviews ((self om-abstract-layout) &rest subviews) (capi::apply-in-pane-process self #'(lambda () (let ((layout-desc (capi::layout-description self))) (loop for item in subviews do (setf layout-desc (remove item layout-desc :test 'equal))) (setf (capi::layout-description self) layout-desc))) )) ; need to remove the subviews from contained layout also. (defmethod om-remove-all-subviews ((self t)) nil) (defmethod om-remove-all-subviews ((self om-abstract-layout)) (capi::apply-in-pane-process self #'(lambda () (mapcar 'om-remove-all-subviews (capi::layout-description self)) (om-set-layout-ratios self nil) (setf (capi::layout-description self) nil)))) (defmethod om-substitute-subviews ((self om-abstract-layout) old new) (capi::apply-in-pane-process self #'(lambda () (om-remove-all-subviews old) (setf (capi::layout-description self) (substitute new old (capi::layout-description self) :test 'equal))) )) (defmethod om-invalidate-view ((self om-abstract-layout)) (mapc 'om-invalidate-view (capi::layout-description self))) ;;;================================ ;;; SPECIAL FOR TAB-LAYOUT ;;;================================ (defmethod om-get-current-view ((self om-tab-layout)) (capi::tab-layout-visible-child self)) (defmethod om-set-current-view ((self om-tab-layout) view) (let ((num (capi::search-for-item self view))) (when num (setf (capi::choice-selection self) num)))) (defmethod om-subviews ((self om-tab-layout)) (loop for i from 0 to (1- (length (capi::collection-items self))) collect (capi::get-collection-item self i))) (defmethod om-remove-subviews ((self om-tab-layout) &rest subviews) (capi::apply-in-pane-process self #'(lambda () (setf (capi::collection-items self) (loop for i from 0 to (1- (length (capi::collection-items self))) unless (find (capi::get-collection-item self i) subviews) collect (capi::get-collection-item self i))) ))) (defmethod om-remove-all-subviews ((self om-tab-layout)) (capi::apply-in-pane-process self #'(lambda () (mapcar 'om-remove-all-subviews (capi::layout-description self)) (dotimes (i (length (capi::collection-items self))) (om-remove-all-subviews (capi::get-collection-item self i))) (setf (capi::layout-description self) nil) (setf (capi::collection-items self) nil) ))) (defmethod om-substitute-subviews ((self om-tab-layout) old new) (capi::apply-in-pane-process self #'(lambda () (om-remove-all-subviews old) (setf (capi::collection-items self) (loop for i from 0 to (1- (length (capi::collection-items self))) collect (if (equal (capi::get-collection-item self i) old) new (capi::get-collection-item self i))) ) ))) (defmethod om-add-subviews ((self om-tab-layout) &rest subviews) (capi::apply-in-pane-process self #'(lambda () (capi::append-items self subviews)))) ;;;================================ ;;; LAYOUT HANDLES SUBVIEWS ;;;================================ (defmethod om-subviews ((self om-abstract-window)) (om-subviews (capi::pane-layout self))) (defmethod om-add-subviews ((self om-abstract-window) &rest subviews) (apply 'om-add-subviews (cons (capi::pane-layout self) subviews))) (defmethod om-remove-subviews ((self om-abstract-window) &rest subviews) (apply 'om-remove-subviews (cons (capi::pane-layout self) subviews))) (defmethod om-remove-all-subviews ((self om-abstract-window)) (apply 'om-remove-all-subviews (list (capi::pane-layout self)))) (defmethod om-substitute-subviews ((self om-abstract-window) old new) (om-substitute-subviews (capi::pane-layout self) old new))

Common Lisp

.lisp

cac-t-u-s/om-sharp

GPL-3.0

9/19/2024, 11:25:22 AM (Europe/Amsterdam)

a7da5aa018dd4bd6028c929fcbea0443c66b98f9a6e9946a8b3aec47d6edacd7

window.lisp

cac-t-u-s_om-sharp/src/api/om-api-LW/window.lisp

;========================================================================= ; OM API ; Multiplatform API for OpenMusic ; LispWorks Implementation ;========================================================================= ; ; This program 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. ; ; This program 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 this program. If not, see <http://www.gnu.org/licenses/>. ; ;========================================================================= ; Authors: J. Bresson, C. Agon ;========================================================================= ;=========================================================================== ; GUI WINDOWS ;=========================================================================== (export '(om-window om-make-window om-window-title om-set-window-title om-interior-size om-set-interior-size om-def-higher-level-win om-front-window om-get-all-windows om-fullscreen-window om-screen-size om-maximize-window om-dialog om-textured-dialog om-modal-dialog om-return-from-modal-dialog om-windoid om-no-border-win om-window-check-before-close om-window-close-event om-close-window om-window-open-p om-window-visible-p om-select-window om-hide-window om-show-window om-open-window om-window-activate om-window-resized om-window-moved om-window-maximized om-minimum-size om-remove-all-subviews om-substitute-subviews ) :om-api) (in-package :oa) ;;;============================================= ;;; OM-ABSTRACT-WINDOW ;;; Superclass of all windows ;;;============================================= (defclass om-abstract-window (om-graphic-object capi::interface) ((resizable :initarg :resizable :initform t :accessor resizable) (fullscreen :initarg :fullscreen :initform nil :accessor fullscreen)) (:default-initargs :auto-menus nil :geometry-change-callback 'om-geometry-change-callback :activate-callback 'om-activate-callback :confirm-destroy-function 'om-confirm-destroy-function :help-callback 'om-help-callback :create-callback 'om-create-callback :destroy-callback 'om-destroy-callback )) (defmethod om-create-callback ((self om-abstract-window)) (setf (initialized-p self) t) t) ;;; Called by CAPI when destroying the window (defmethod om-destroy-callback ((self om-abstract-window)) (capi::execute-with-interface self 'om-window-close-event self) (setf (initialized-p self) nil)) ;;; OM event handler (defmethod om-window-close-event ((self t)) nil) (defmethod om-activate-callback (self activatep)) (defun om-confirm-destroy-function (self) (om-window-check-before-close self)) (defmethod om-window-check-before-close ((self t)) t) (defmethod om-help-callback ((interface t) pane type key)) (defmethod om-view-key-handler ((self om-abstract-window) key) nil) (defmethod om-get-view ((self om-abstract-window)) (capi::pane-layout self)) (defmethod om-window-title ((self om-abstract-window)) (capi::interface-title self)) (defmethod om-set-window-title ((self om-abstract-window) (title string)) (capi:execute-with-interface self #'(lambda () (setf (capi::interface-title self) title)))) (defmethod om-view-position ((self om-abstract-window)) (if (capi::interface-visible-p self) (let ((point (capi::interface-geometry self))) (om-make-point (first point) (second point))) (om-make-point (vx self) (vy self)))) (defmethod om-set-view-position ((self om-abstract-window) pos-point) (when (capi::interface-visible-p self) (capi::execute-with-interface self 'capi::set-top-level-interface-geometry self :x (om-point-x pos-point) :y (om-point-y pos-point))) (setf (vx self) (om-point-x pos-point)) (setf (vy self) (om-point-y pos-point))) (defmethod om-view-size ((self om-abstract-window)) (if (capi::interface-visible-p self) (let ((point (capi::interface-geometry self))) #+win32(om-make-point (- (third point) (car point)) (- (fourth point) (cadr point))) #-win32(om-make-point (third point) (fourth point)) ) (om-make-point (vw self) (vh self)))) (defun set-not-resizable (win &key (w nil w-supplied-p) (h nil h-supplied-p)) (let ((width (if w-supplied-p (or w (om-point-x (om-view-size win))))) (height (if h-supplied-p (or h (om-point-y (om-view-size win)))))) (capi::set-hint-table win (list :external-min-width width :external-max-width width :external-min-height height :external-max-height height )))) (defmethod om-set-view-size ((self om-abstract-window) size-point) (let ((wi (om-point-x size-point)) (he (om-point-y size-point))) (capi::execute-with-interface self #'(lambda (w h) (unless (resizable self) (set-not-resizable self :w w :h h)) (when (capi::interface-visible-p self) (capi::set-top-level-interface-geometry self :width w :height h )) (setf (vw self) w (vh self) h) (om-window-resized self size-point) ) wi he) )) (defmethod om-interior-size ((self om-abstract-window)) #+win32(if (capi::interface-visible-p (capi::pane-layout self)) (multiple-value-bind (w h) (capi::pinboard-pane-size (capi::pane-layout self)) (om-make-point w h)) (om-view-size self)) #-win32(om-view-size self) ) (defmethod om-set-interior-size ((self om-abstract-window) size) (om-set-view-size self size)) (defmethod om-geometry-change-callback ((self om-abstract-window) x y w h) (unless (and (vx self) (vy self) (= x (vx self)) (= y (vy self))) (om-window-moved self (om-make-point x y))) (unless (and (vw self) (vh self) (= w (vw self)) (= h (vh self))) (om-window-resized self (om-make-point w h)) #+windows(om-invalidate-view self) ) (setf (vx self) x (vy self) y (vw self) w (vh self) h)) (defmethod om-window-resized ((self om-abstract-window) size) (declare (ignore self size)) nil) (defmethod om-window-moved ((self om-abstract-window) pos) (declare (ignore self pos)) nil) (defmethod om-window-maximized ((self om-abstract-window)) (equal (capi::top-level-interface-display-state self) :maximized)) (defmethod om-maximize-window ((self om-abstract-window)) (setf (capi::top-level-interface-display-state self) :maximized)) (defmethod om-minimum-size ((self om-abstract-window)) (declare (ignore self)) nil) (defmethod capi::calculate-constraints ((self om-abstract-window)) (declare (special capi:%min-width% capi:%min-height%)) (call-next-method) (let ((msize (om-minimum-size self))) (when msize (capi::with-geometry self (setf capi:%min-width% (om-point-x msize)) (setf capi:%min-height% (om-point-y msize)) )))) (defmethod om-fullscreen-window ((self om-abstract-window)) (setf (fullscreen self) t) (om-set-view-position self (om-make-point 0 0)) (om-set-view-size self (om-make-point (capi::screen-width (capi:convert-to-screen self)) (- (capi::screen-height (capi:convert-to-screen self)) 20))) ) (defun om-screen-size () (om-make-point (capi::screen-width (capi:convert-to-screen nil)) (capi::screen-height (capi:convert-to-screen nil)))) (defun om-front-window () #+cocoa (capi:screen-active-interface (capi:convert-to-screen)) #-cocoa ; crashes sometimes :( (car (capi::collect-interfaces 'om-abstract-window :screen :any :sort-by :visible)) ) (defun om-get-all-windows (class) (capi::collect-interfaces class)) (defmethod interface-match-p ((self om-abstract-window) &rest initargs &key name) (string-equal (capi::capi-object-name self) name)) (defmethod om-select-window ((self capi::interface)) #-linux(capi::raise-interface self) #+linux(capi::find-interface (type-of self) :name (capi::capi-object-name self)) self) (defmethod om-hide-window ((self om-abstract-window)) (capi::execute-with-interface self #'(lambda (x) (setf (capi::top-level-interface-display-state x) :hidden)) self)) (defmethod om-window-visible-p ((self om-abstract-window)) (capi::interface-visible-p self)) (defmethod om-show-window ((self t)) (capi::execute-with-interface self #'capi::show-interface self) self) (defmethod om-open-window ((self t)) (capi::execute-with-interface self #'(lambda (x) (capi::display x)) self)) (defmethod om-close-window ((win t)) (when win (capi:apply-in-pane-process win 'capi:quit-interface win))) (defmethod initialized-p ((self t)) t) (defun om-window-open-p (window) (and (initialized-p window) (not (equal (capi::interface-created-state window) :destroyed)))) (defmethod om-activate-callback ((self om-abstract-window) activatep) (om-window-activate self activatep)) ;;; OM event handler (defmethod om-window-activate ((self om-abstract-window) &optional (activatep t)) t) ;;;============================================= ;;; OM-WINDOW ;;; A simple window with a panel able to host subviews ;;;============================================= (defclass om-window (om-abstract-window) ()) ;;;==================== ;;; DIALOG ;;; Pour mettre des dialog-items ;;; Des interfaces modales, etc. ;;;==================== (defclass om-dialog (om-abstract-window) ()) (defclass om-textured-dialog (om-dialog) ()) (defmethod window-dialog-p ((self om-dialog)) t) (defmethod om-select-window ((self om-dialog)) (if (initialized-p self) #+cocoa(capi::raise-interface self) #-cocoa(capi::find-interface (type-of self) :name (capi::capi-object-name self)) (capi::display self)) self) (defun om-modal-dialog (dialog &optional (owner nil)) ;(update-for-subviews-changes dialog t) (capi::display-dialog dialog :owner (or owner (capi:convert-to-screen)) ; (om-front-window) :position-relative-to (and owner :owner) :x (vx dialog) :y (vy dialog))) (defun om-return-from-modal-dialog (dialog val) (declare (ignore dialog)) (capi::exit-dialog val)) ;;;==================== ;;; PALETTE ;;; Always on top, petite barre de titre ;;;==================== (defclass om-windoid (om-window) ((accept-key-evt :accessor accept-key-evt :initarg :accept-key-evt :initform nil)) (:default-initargs :draw-with-buffer t) ; :window-styles '(:internal-borderless :always-on-top :borderless :shadowed)) ) (defmethod internal-display ((self om-windoid)) ;#+win32(capi::display self :process nil) (capi::display self)) ;;;==================== ;;; NO BORDER ;;;==================== (defclass om-no-border-win (om-window) ()) (defmethod om-fullscreen-window ((self om-no-border-win)) (call-next-method)) ;;;================================ ;;; MAKE WINDOW ;;;================================ (defmethod internal-display ((self t)) (capi::display self)) (defmethod window-dialog-p ((self t)) nil) ; :movable-by-window-background ; :borderless ; :shadowed (defmethod get-window-styles-from-class ((class t)) (cond ((subtypep class 'om-windoid) '(:always-on-top :toolbox ;:textured-background ;--> removed because it creates movable-by-bg :no-geometry-animation :ignores-keyboard-input )) ; ((subtypep class 'om-no-border-win) '(:borderless :shadowed :always-on-top)) ((subtypep class 'om-window) '(:motion-events-without-focus)) ((subtypep class 'om-textured-dialog) '(:textured-background)) ((subtypep class 'om-dialog) '(:no-geometry-animation)) )) (defun om-make-window (class &rest attributes &key position size name title owner bg-color border menu-items win-layout (show t) subviews (resizable t) (close t) (minimize t) (maximize t) (topmost nil) (toolbox nil) &allow-other-keys) (declare (ignore close maximize)) ;;; enable these options someday :) (let* ((winparent (or owner (capi:convert-to-screen))) (winname (or name title (string (gensym)))) (wintitle (or title name "")) (w (and size (om-point-x size))) (h (and size (om-point-y size))) (x (and position (if (equal position :centered) (round (- (* (capi::screen-width winparent) 0.5) (* (or w 0) 0.5))) (om-point-x position)))) (y (and position (if (equal position :centered) (round (- (* (capi::screen-height winparent) 0.5) (* (or h 0) 0.5))) (om-point-y position)))) (style (append (get-window-styles-from-class class) (when (not minimize) (list :never-iconic)) (when topmost (list :always-on-top)) (when toolbox (list :toolbox)) (list :no-character-palette ;:internal-borderless ))) win) (setf win (apply 'make-instance (append (list class :title wintitle :name winname :x x :y y :width w :height h :auto-menus nil :parent winparent :internal-border border :external-border nil :display-state (if show :normal :hidden) :menu-bar-items menu-items :window-styles style :resizable resizable ;;; OM-GRAPHIC-OBJECT SLOTS :vx x :vy y :vw w :vh h :allow-other-keys t ) attributes ))) (capi::execute-with-interface win #'(lambda () (setf (capi::pane-layout win) (if (or (null win-layout) (symbolp win-layout)) (make-instance (or win-layout 'om-simple-layout) :internal-border nil :visible-border nil :accepts-focus-p nil) win-layout)) (when bg-color (setf (capi::simple-pane-background (capi::pane-layout win)) (omcolor-c bg-color))) (when subviews (setf (capi::layout-description (capi::pane-layout win)) subviews)) (unless (window-dialog-p win) (internal-display win)) (unless (equal resizable t) ; (and w h (or (not resizable) (window-dialog-p win))) (apply 'set-not-resizable (append (list win) (unless (equal resizable :w) (list :w w)) (unless (equal resizable :h) (list :h h)) ))) )) win))

Common Lisp

.lisp

cac-t-u-s/om-sharp

GPL-3.0

9/19/2024, 11:25:22 AM (Europe/Amsterdam)

5066fc043aac40618a62a3d7e9b2fa1c869c3debcea729b541554556a967cb63

print.lisp

cac-t-u-s_om-sharp/src/api/om-api-LW/print.lisp

;========================================================================= ; OM API ; Multiplatform API for OpenMusic ; LispWorks Implementation ;========================================================================= ; ; This program 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. ; ; This program 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 this program. If not, see <http://www.gnu.org/licenses/>. ; ;========================================================================= ; Authors: C. Agon ;========================================================================= ;;=========================================================================== ; PRINT UTILITY ;;=========================================================================== ;;; NOT USED ATM (in-package :om-api) (export '(om-page-setup om-print-window om-print-one-page om-print-view om-compute-page-number om-print-document om-score-paper-size ) :om-api) (defvar *score-thickness* nil) (setf *score-thickness* 0.4) (defun om-draw-score-line (x1 y1 x2 y2) (gp:draw-line *curstream* x1 y1 x2 y2 :thickness *score-thickness* )) (defun om-page-setup () (capi::page-setup-dialog)) (defmethod om-print-window ((self om-abstract-window)) (om-print-document self)) ;print the window in one page (defun om-print-one-page (self) (let ((image (gp::make-image-from-port (om-get-view self) 0 0 (- (om-width self) 15) (- (om-height self) 15)))) (when image (let ((printer (capi:print-dialog :print-pages-p nil :print-copies-p t))) (when printer (let ((printer-metrics (get-printer-metrics printer)) (dpi-x (printer-metrics-dpi-x printer-metrics)) (dpi-y (printer-metrics-dpi-y printer-metrics))) (when printer (capi:with-print-job (printer-port :printer printer) (multiple-value-bind (page-width page-height) (capi:get-page-area printer) (let* ((drawing-width (- (om-width self) 15)) (drawing-height (- (om-height self) 15)) (widen-p (> (/ page-width page-height) (/ drawing-width drawing-height))) (page-transform-x 0) (page-transform-y 0) (page-transform-width (if widen-p (* page-width (/ drawing-height page-height)) drawing-width)) (page-transform-height (if widen-p drawing-height (* page-height (/ drawing-width page-width))))) (capi:with-document-pages (page 1 1) ; all on one page (capi:with-page-transform (page-transform-x page-transform-y page-transform-width page-transform-height) (draw-image printer-port image 0 0))))))) ))) ))) ;print in n pages (defvar *default-printer-port* nil) (defmethod om-print-document ((self om-graphic-object)) (let* ((printer (capi:print-dialog :print-pages-p nil :print-copies-p t)) (printer-metrics (get-printer-metrics printer)) (dpi-x (printer-metrics-dpi-x printer-metrics)) (dpi-y (printer-metrics-dpi-y printer-metrics))) (when printer (capi:with-print-job (printer-port :printer printer) (multiple-value-bind (page-width page-height) (capi:get-page-area printer) (let* ((page-count (om-compute-page-number self (om-make-point page-width page-height)))) (capi:with-document-pages (page 1 page-count) (let ((*default-printer-port* printer-port)) (om-print-view self (om-make-point page-width page-height) page page-count))))))))) (defmethod om-compute-page-number ((view om-graphic-object) page-size ) (declare (ignore page-size )) 1) (defmethod om-score-paper-size () (let ((printer (current-printer)) rep) (multiple-value-bind (page-width page-height) (capi:get-page-area printer) (setf rep (om-make-point page-width page-height))) rep))

Common Lisp

.lisp

cac-t-u-s/om-sharp

GPL-3.0

9/19/2024, 11:25:22 AM (Europe/Amsterdam)

d8470416c89e95c01ac7c8549aa014b6db6045943d0761271bc077dadc662f1b

view.lisp

cac-t-u-s_om-sharp/src/api/om-api-LW/view.lisp

;========================================================================= ; OM API ; Multiplatform API for OpenMusic ; LispWorks Implementation ;========================================================================= ; ; This program 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. ; ; This program 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 this program. If not, see <http://www.gnu.org/licenses/>. ; ;========================================================================= ; Authors: J. Bresson, C. Agon ;========================================================================= ;=========================================================================== ; OM-VIEW CLASSES : container panes for GUI windows ;=========================================================================== (export '( om-view om-make-view om-view-parent om-scroll-position om-set-scroll-position om-h-scroll-position om-v-scroll-position om-view-scrolled om-view-resized om-view-contains-point-p om-find-view-containing-point om-convert-coordinates om-view-origin om-get-subview-with-focus om-set-view-enabled om-view-enabled) :om-api) (in-package :oa) ;;;====================== ;;; VIEW ;;; General graphic pane ;;;====================== (defclass om-view (capi::pinboard-layout om-graphic-object om-interactive-object) ((item-subviews :initarg :item-subviews :initform nil :accessor item-subviews) ;(main-pinboard-object :accessor main-pinboard-object :initarg :main-pinboard-object :initform nil) ) (:default-initargs :draw-with-buffer t :highlight-style :standard :scroll-if-not-visible-p nil ;:fit-size-to-children t :resize-callback 'om-resize-callback :scroll-callback 'om-scroll-callback :create-callback 'om-create-callback :destroy-callback 'om-destroy-callback #+macosx :background #+macosx :transparent ;#+windows :draw-pinboard-objects #+windows :once ;:local-buffer :buffer :once )) (defmethod om-view-p ((self om-view)) t) (defmethod om-view-p ((self t)) nil) (defmethod om-create-callback ((self om-view)) (update-for-subviews-changes self nil) (setf (initialized-p self) t)) (defmethod om-destroy-callback ((self om-view)) nil) ;;; background pinboard for drawing on the view ;;; must keep the same size as the view ;(defclass om-view-pinboard-object (capi::pinboard-object) ()) ;(defmethod om-get-view ((self om-view-pinboard-object)) (capi::pinboard-object-pinboard self)) ;;;======================================= (defmethod om-scroll-position ((self om-view)) (om-make-point (om-h-scroll-position self) (om-v-scroll-position self))) (defmethod om-set-scroll-position ((self om-view) pos) (capi::scroll self :pan :move (list (om-point-x pos) (om-point-y pos)))) (defmethod om-h-scroll-position ((self om-view)) (or (capi::get-horizontal-scroll-parameters self :slug-position) 0)) (defmethod om-v-scroll-position ((self om-view)) (or (capi::get-vertical-scroll-parameters self :slug-position) 0)) (defmethod om-h-scroll-position ((self om-graphic-object)) 0) (defmethod om-v-scroll-position ((self om-graphic-object)) 0) (defmethod om-scroll-position ((self om-graphic-object)) (om-make-point 0 0)) (defmethod om-subviews ((self om-view)) (append (call-next-method) nil)) ; (item-subviews self))) (defmethod om-view-parent ((self om-view)) (capi::element-parent self)) ;;;======================================= (defmethod set-layout ((view om-view)) (setf (capi:layout-description view) (remove-duplicates (remove nil ;(cons (main-pinboard-object view) (append (vsubviews view) (item-subviews view))))) ) (defmethod set-layout ((view t)) nil) (defmethod update-for-subviews-changes ((self om-view) &optional (recursive nil)) (capi::apply-in-pane-process self (lambda () (set-layout self) ;;(capi:remove-capi-object-property self 'capi::prev-width-height) )) (when recursive (mapc #'(lambda (view) (if (om-view-p view) (update-for-subviews-changes view t))) (vsubviews self)))) (defun om-make-view (class &rest attributes &key position size (resizable t) owner subviews name bg-color fg-color font scrollbars (enabled t) (direct-draw t) ;;; DIRECT-DRAW = NIL ALLOWS DRAWING PINBOARDS &allow-other-keys) (let ((x (and position (om-point-x position))) (y (and position (om-point-y position))) (w (and size (om-point-x size))) (h (and size (om-point-y size))) (initargs-list (list :name name :font (or font (om-def-font :normal)) :vcontainer owner ;:automatic-resize '(:width-ratio 0.5 :aspect-ratio 0.6) :accepts-focus-p enabled :pane-can-scroll nil :horizontal-scroll (when (or (equal scrollbars t) (equal scrollbars :h)) scrollbars) :vertical-scroll (when (or (equal scrollbars t) (equal scrollbars :v)) scrollbars) :allow-other-keys t))) ;:x x :y y ;; for pinboard-objects ;;; :focus-callback #'(lambda (a b) (print (list a b)))) (setf initargs-list (append initargs-list (and x (list :default-x x :vx x)) (and y (list :default-y y :vy y)) (and w (list :width NIL :default-width w :visible-min-width w :visible-max-width (if (or (equal resizable t) (equal resizable :w)) nil w) :scroll-width w :vw w )) (and h (list :height NIL :default-height h :visible-min-height h :visible-max-height (if (or (equal resizable t) (equal resizable :h)) nil h) :scroll-height h :vh h)) )) (let ((view (apply 'make-instance (cons class (append initargs-list attributes))))) (when bg-color (om-set-bg-color view bg-color)) (when fg-color (om-set-fg-color view fg-color)) (when owner (om-add-subviews owner view)) (when subviews (mapc (lambda (sv) (om-add-subviews view sv)) (remove nil subviews))) ;#mswindows(unless (or bg-color (simple-pane-background view)) (om-set-bg-color view (om-def-color :white))) ;#+win32(setf (main-pinboard-object view) (make-instance 'om-view-pinboard-object)) ;#+win32(setf (capi::pinboard-pane-size (main-pinboard-object view)) (values w h)) ; #+cocoa (when direct-draw (setf (capi::output-pane-display-callback view) 'om-draw-contents-callback)) ;(when (om-view-p view) ; (setf (capi::simple-pane-scroll-callback view) 'scroll-update) ; (capi:apply-in-pane-process view #'(lambda () ; (capi::set-horizontal-scroll-parameters view :min-range 0 :max-range 200) ; (capi::set-vertical-scroll-parameters view :min-range 0 :max-range 200) ; ))) view))) (defmethod om-resize-callback ((self om-view) x y w h) (setf (vx self) x (vy self) y) (when (and (vw self) (vh self)) (unless (and (= w (vw self)) (= h (vh self))) (setf (vw self) w (vh self) h) (om-view-resized self (om-make-point w h))))) (defmethod om-view-resized ((self om-view) size) (declare (ignore self size)) nil) (defmethod om-scroll-callback ((self om-view) dir op val &key interactive) ;(print (list self dir op val)) (when interactive (om-view-scrolled self (case dir (:vertical (list 0 (if (equal op :step) (om-v-scroll-position self) val))) (:horizontal (list (if (equal op :step) (om-h-scroll-position self) val) 0)) (:pan val))) )) (defmethod om-view-scrolled ((self om-view) xy) (declare (ignore self xy)) nil) (defmethod om-set-view-enabled ((self om-view) enabled) (setf (capi::simple-pane-enabled self) enabled)) (defmethod om-view-enabled ((self om-view)) (capi::simple-pane-enabled self))

Common Lisp

.lisp

cac-t-u-s/om-sharp

GPL-3.0

9/19/2024, 11:25:22 AM (Europe/Amsterdam)

449166bbb429605e7aa028394b116f9736849f64f2706de5f26785947e70a7ba

tools.lisp

cac-t-u-s_om-sharp/src/api/om-api-LW/tools.lisp

;========================================================================= ; OM API ; Multiplatform API for OpenMusic ; LispWorks Implementation ;========================================================================= ; ; This program 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. ; ; This program 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 this program. If not, see <http://www.gnu.org/licenses/>. ; ;========================================================================= ; Authors: J. Bresson, C. Agon ;========================================================================= ;;=========================================================================== ; Misc. TOOLS ;;=========================================================================== (in-package :om-api) (export '(ratiop function-name method-name function-arglist function-documentation class-documentation class-instance-slots class-direct-instance-slots slot-name slot-initform slot-initargs slot-type slot-doc ) :om-api) ;======================== ; Lisp ;======================== (import 'ratiop :lispworks) ;======================== ; FUNCTION NAMES AND DOC ;======================== ;;; cases and examples: ;;; generic function, e.g. 'om::om+ ;;; functio,, e.g. 'append ;;; special "macro-function", e.g. 'setf ;;; anonymmous function ;;; subfunction ;;; struct accessors ; (function-name (fdefinition 'pathname-name)) (defun function-arglist (fun) (let ((fsym (if (symbolp fun) fun (function-name fun))) (fdef (if (symbolp fun) (fdefinition fun) fun))) (cond ((clos::generic-function-p fdef) (hcl::method-lambda-list (car (hcl::generic-function-methods fdef)))) ((macro-function fsym) (function-lambda-list fsym)) (fsym (clos::extract-lambda-list-names-and-keys (function-lambda-list fsym))) (t (function-lambda-list fun))) )) (defmethod function-name ((fun symbol)) fun) (defmethod function-name (fun) (if (clos::generic-function-p fun) (hcl::generic-function-name fun) (let ((lambda-exp-name (nth 2 (multiple-value-list (FUNCTION-LAMBDA-EXPRESSION fun))))) (cond ((equal lambda-exp-name 'system::fast-list) 'list) ((symbolp lambda-exp-name) lambda-exp-name) ;; does not work, e.g. for CONS... ;; removed because struct-accessors fail here: ;; ((consp lambda-exp-name) nil) ;; the function is (?) a subfunction named by the compiler (t (system::function-name fun)) ;;; does not work with non-inbuilt functions... )))) ;; does not work with structure accessors ;;(function-name (fdefinition (read-from-string "las::las-sound-ptr"))) (defun method-name (method) (clos::generic-function-name (clos::method-generic-function method))) #| ; OMMethod defined in OM# (function-documentation 'om::om+) ; Lisp fun defined in OM# (function-documentation 'first) ; known special cases: (function-documentation 'if) (function-documentation 'om::repeat-n) |# (defun function-documentation (function) (or (common-lisp::documentation function 'function) (system::function-documentation function))) ;================= ; CLOS/MOP ;================= (defun get-class-precedence-list (class) (hcl::class-precedence-list class)) (defun get-class-default-initargs (class) (hcl::class-default-initargs class)) (defun class-slots (class) (hcl::class-slots class)) (defun class-direct-slots (class) (hcl::class-direct-slots class)) (defun slot-name (slot) (clos::slot-definition-name slot)) (defun slot-allocation (slot) (clos::slot-definition-allocation slot)) (defun slot-initargs (slot) (clos::slot-definition-initargs slot)) (defun slot-initform (slot) (clos::slot-definition-initform slot)) (defun slot-type (slot) (clos::slot-definition-type slot)) (defun slot-doc (slot) (slot-value slot 'clos::documentation-slot)) (defun class-documentation (class) (let ((realclass (if (symbolp class) (find-class class nil) class))) (if realclass (system::class-documentation realclass) (concatenate 'string "Class " (string class) " not found")))) (defun class-instance-slots (class) (remove :class (class-slots class) :test 'equal :key 'slot-allocation)) (defun class-direct-instance-slots (class) (remove :class (class-direct-slots class) :test 'equal :key 'slot-allocation)) (defun class-class-slots (class) (remove :instance (class-slots class) :test 'equal :key 'slot-allocation)) ;================= ; Special LW compatibility (in-package :cl-user) (defun set-nthcdr (index list new-value) "If INDEX is 0, just return NEW-VALUE." (if (not (zerop index)) (rplacd (nthcdr (1- index) list) new-value)) new-value) (let ((lispworks::*HANDLE-WARN-ON-REDEFINITION* nil)) (defsetf nthcdr set-nthcdr))

Common Lisp

.lisp

cac-t-u-s/om-sharp

GPL-3.0

9/19/2024, 11:25:22 AM (Europe/Amsterdam)

d3e26e3f68e9142d16b2a48e28e0c1dbab585763a3b0408b6a73999516185504

actions.lisp

cac-t-u-s_om-sharp/src/api/om-api-LW/actions.lisp

;========================================================================= ; OM-API ; Multiplatform API for OpenMusic ; LispWorks Implementation ;========================================================================= ; ; This program 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. ; ; This program 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 this program. If not, see <http://www.gnu.org/licenses/>. ; ;========================================================================= ; Author: J. Bresson, C. Agon ;========================================================================= ;;=========================================================================== ; OM-GRAPHIC OBJECTS ACTIONS CALLBACKS ;;=========================================================================== (export '( om-input-model om-view-key-handler om-view-click-handler om-view-right-click-handler om-view-doubleclick-handler om-view-mouse-enter-handler om-view-mouse-leave-handler om-view-mouse-motion-handler om-reset-mouse-motion om-view-pan-handler om-view-zoom-handler om-init-motion om-click-motion-handler om-click-release-handler om-shift-key-p om-command-key-p om-option-key-p om-mouse-position ) :om-api) (in-package :om-api) (defparameter +control-button+ #+macosx :hyper #-macosx :control) (defparameter +2nd-press+ #+win32 :second-press #-win32 :nth-press) (defparameter +2nd-press-callback+ #+win32 'om-double-clic-callback #-win32 'om-multiple-clic-callback) (defclass om-interactive-object () () (:default-initargs :input-model (om-input-model :touch-pan nil))) ;;; view classes who want to ovrride the default scroll to define their own ;;; pan gesture should override the :input-mode initarg with (om-input-model :touch-pan T) (defun om-input-model (&key touch-pan) (remove nil `( ;;; CALLBACKS ARGUMENTS = (SHIF CMD OPTION) ((:button-1 :motion :shift ,+control-button+ :meta) om-clic-motion-callback (t t t)) ((:button-1 :motion :shift ,+control-button+) om-clic-motion-callback (t t nil)) ((:button-1 :motion :shift :meta) om-clic-motion-callback (t nil t)) ((:button-1 :motion :meta ,+control-button+) om-clic-motion-callback (nil t t)) ((:button-1 :motion :shift) om-clic-motion-callback (t nil nil)) ((:button-1 :motion ,+control-button+) om-clic-motion-callback (nil t nil)) ((:button-1 :motion :meta) om-clic-motion-callback (nil nil t)) ((:button-1 :motion) om-clic-motion-callback (nil nil nil)) ((:button-1 :press :shift ,+control-button+ :meta) om-clic-callback (t t t)) ((:button-1 :press :shift ,+control-button+) om-clic-callback (t t nil)) ((:button-1 :press :shift :meta) om-clic-callback (t nil t)) ((:button-1 :press :meta ,+control-button+) om-clic-callback (nil t t)) ((:button-1 :press :shift) om-clic-callback (t nil nil)) ((:button-1 :press ,+control-button+) om-clic-callback (nil t nil)) ((:button-1 :press :meta) om-clic-callback (nil nil t)) ((:button-1 :press) om-clic-callback (nil nil nil)) ((:motion :shift ,+control-button+) om-motion-callback (t t nil)) ((:motion :shift) om-motion-callback (t nil nil)) ((:motion ,+control-button+) om-motion-callback (nil t nil)) (:motion om-motion-callback (nil nil nil)) ((:button-1 :release :shift ,+control-button+ :meta) om-clic-release-callback (t t t)) ((:button-1 :release :shift ,+control-button+) om-clic-release-callback (t t nil)) ((:button-1 :release :shift :meta) om-clic-release-callback (t nil t)) ((:button-1 :release :meta ,+control-button+) om-clic-release-callback (nil t t)) ((:button-1 :release :shift) om-clic-release-callback (t nil nil)) ((:button-1 :release ,+control-button+) om-clic-release-callback (nil t nil)) ((:button-1 :release :meta) om-clic-release-callback (nil nil t)) ((:button-1 :release) om-clic-release-callback (nil nil nil)) ((:button-1 ,+2nd-press+ :shift ,+control-button+ :meta) ,+2nd-press-callback+ (t t t)) ((:button-1 ,+2nd-press+ :shift ,+control-button+) ,+2nd-press-callback+ (t t nil)) ((:button-1 ,+2nd-press+ :shift :meta) ,+2nd-press-callback+ (t nil t)) ((:button-1 ,+2nd-press+ :meta ,+control-button+) ,+2nd-press-callback+ (nil t t)) ((:button-1 ,+2nd-press+ :shift ) ,+2nd-press-callback+ (t nil nil)) ((:button-1 ,+2nd-press+ ,+control-button+) ,+2nd-press-callback+ (nil t nil)) ((:button-1 ,+2nd-press+ :meta) ,+2nd-press-callback+ (nil nil t)) ((:button-1 ,+2nd-press+) ,+2nd-press-callback+ (nil nil nil)) ;(:post-menu om-context-menu-callback) ((:button-3 :press) om-context-menu-callback) ((:button-3 :release) om-right-clic-callback (nil nil nil)) ((:button-3 :second-press) om-right-clic-callback (nil nil nil)) #-linux,(when touch-pan '((:touch :pan) om-pan-callback)) #-linux((:touch :zoom) om-zoom-callback) (:gesture-spec om-char-spec-callback) ;; (:character om-char-callback (nil nil nil)) ))) #| (defmethod om-motion-callback ((self om-interactive-object) x y modifiers) t) (defmethod om-clic-callback ((self om-interactive-object) x y modifiers)) (defmethod om-clic-release-callback ((self om-interactive-object) x y modifiers)) (defmethod om-clic-motion-callback ((self om-interactive-object) x y modifiers)) (defmethod om-double-clic-callback ((self om-interactive-object) x y modifiers)) (defmethod om-right-clic-callback ((self om-interactive-object) x y)) (defmethod om-context-menu-callback ((self om-interactive-object) x y)) (defmethod om-char-callback ((self om-interactive-object) x y c modifiers)) (defmethod om-char-spec-callback ((self om-interactive-object) x y modifiers)) |# ;;;======================= ;;; MOUSE ;;;======================= ;;;=============== ;;; TOOLS ;;;=============== (defun internal-mouse-position (view) (or (ignore-errors (multiple-value-bind (x y) (if view (capi::current-pointer-position :relative-to view :pane-relative-p t) (capi::current-pointer-position)) (om-make-point x y))) (om-make-point 0 0))) (defmethod om-mouse-position ((view null)) (internal-mouse-position nil)) (defmethod om-mouse-position ((view om-graphic-object)) (internal-mouse-position view)) ;;; Event dispatcher on item subviews (om-view catches events but om-item-views do not) ;;; if function callback is non-NIL for one of the subviews, recursive dispatching is stopped. (defmethod apply-in-item-subview ((self t) function position) nil) (defmethod apply-in-item-subview ((self capi::pinboard-layout) function position) (let ((po (capi::pinboard-object-at-position self (om-point-x position) (om-point-y position)))) (if (and po (om-item-view-p po)) (funcall function po (om-convert-coordinates position self po)) (or po (funcall function self position))))) ;;; Event dispatcher on subviews (when the container has the focus) ;;; useful for mouse move (defmethod apply-in-subview ((self om-graphic-object) function position) (let ((clicked self)) ;(print (list "subviews of" self)) (loop for item in (om-subviews self) while (equal clicked self) do (when (and item (om-view-contains-point-p item position)) (setf clicked (apply-in-subview item function (om-add-points (om-convert-coordinates position self item) (om-scroll-position item)))))) (when (or (null clicked) (equal clicked self)) (setf clicked (apply-in-item-subview self function position))) clicked)) ;;;================= ;;; MOTION & CURSOR ;;;================= (defvar *last-visited-view* nil) (defmethod om-motion-callback ((self om-interactive-object) x y modifiers) (set-meta-keys modifiers) (handle-tooltips-in-motion self (om-make-point x y)) (apply-in-subview self 'internal-motion-callback (om-make-point x y))) ;; CF. CURSOR.LISP (defmethod update-view-cursor ((self t) pos) nil) (defun om-reset-mouse-motion () (setf *last-visited-view* nil)) (defmethod internal-motion-callback ((self om-interactive-object) pos) (unless (equal *last-visited-view* self) (when *last-visited-view* (om-view-mouse-leave-handler *last-visited-view*)) ;(om-set-focus self) (update-view-cursor self pos) (om-view-mouse-enter-handler self) (setf *last-visited-view* self)) (om-view-mouse-motion-handler self pos)) (defmethod om-view-mouse-motion-handler ((self om-interactive-object) position) (declare (ignore self position))) (defmethod om-view-mouse-enter-handler ((self t)) (declare (ignore self))) (defmethod om-view-mouse-leave-handler ((self t)) (declare (ignore self))) ;;;============= ;;; CLIC ;;;============= (defvar *clicked-view* nil) (defmethod om-clic-callback ((self om-interactive-object) x y modifiers) (om-with-error-handle (set-meta-keys modifiers) (when (and (< x (+ (vw self) (om-point-x (om-scroll-position self)))) (< y (+ (vh self) (om-point-y (om-scroll-position self))))) ;;; for some reason on windows sometimes the click callback is called even ;;; from outside the panel (e.g. in another pane in teh same layout...) (apply-in-item-subview self 'om-view-click-handler (om-make-point x y)) ))) (defmethod om-view-click-handler ((self om-interactive-object) position) nil) (defmethod om-view-click-handler :before ((self om-interactive-object) position) (setf *clicked-view* self)) (defmethod om-right-clic-callback ((self om-interactive-object) x y modifiers) (om-with-error-handle (set-meta-keys modifiers) (apply-in-item-subview self 'om-view-right-click-handler (om-make-point x y)))) (defmethod om-view-right-click-handler ((self om-interactive-object) position) nil) (defmethod om-view-right-click-handler :before ((self om-interactive-object) position) (setf *clicked-view* self)) ;;;============== ;;; RELEASE ;;;============== (defmethod om-clic-release-callback ((self om-interactive-object) x y modifiers) (set-meta-keys modifiers) (unless (equal *clicked-view* :abort) (if *clicked-view* (om-click-release-handler *clicked-view* (om-convert-coordinates (om-make-point x y) self *clicked-view*)) (apply-in-item-subview self 'om-click-release-handler (om-make-point x y))))) (defmethod om-click-release-handler ((self om-interactive-object) pos) nil) (defmethod om-click-release-handler :before ((self om-interactive-object) position) (setf *clicked-view* nil)) ;;;================= ;;; DOUBLE CLIC ;;;================= (defmethod om-double-clic-callback ((self om-interactive-object) x y modifiers) (om-multiple-clic-callback self x y modifiers 2)) (defmethod om-multiple-clic-callback ((self om-interactive-object) x y modifiers n) (setf *clicked-view* :abort) ;(print (list self x y)) (or (apply-in-item-subview self 'om-view-doubleclick-handler (om-make-point x y)) (apply-in-item-subview self 'om-view-click-handler (om-make-point x y)) )) (defmethod om-view-doubleclick-handler ((self om-interactive-object) pos) nil) ;;;================= ;;; CLIC + MOVE ;;;================= (defmethod om-init-motion (self x y)) (defmethod om-clic-motion-callback ((self om-interactive-object) x y modifiers) (set-meta-keys modifiers) (unless (equal *clicked-view* :abort) (if *clicked-view* (om-click-motion-handler *clicked-view* (om-convert-coordinates (om-make-point x y) self *clicked-view*)) (apply-in-item-subview self 'om-click-motion-handler (om-make-point x y)))) ) (defmethod om-click-motion-handler (self pos) t) ;;;================= ;;; TOUCH GESTURES ;;;================= (defmethod om-zoom-callback ((self om-interactive-object) x y zoom-factor) (om-view-zoom-handler self (om-make-point x y) zoom-factor)) (defmethod om-pan-callback ((self om-interactive-object) x y delta-x delta-y) (om-view-pan-handler self (om-make-point x y) delta-x delta-y)) ;;; need to set *clicked-view* ?? (defmethod om-view-zoom-handler ((self om-interactive-object) position zoom-factor) nil) (defmethod om-view-pan-handler ((self om-interactive-object) position delta-x delta-y) nil) ;;;===================== ;;; KEYBOARD ;;;===================== ;;; CHAR-CALLBACK: NOT USED (defun get-om-character (c) (case (char-code c) (63276 :om-key-pageup) (63277 :om-key-pagedown) (63275 :om-key-end) (63273 :om-key-home) (63234 :om-key-left) (63232 :om-key-up) (63235 :om-key-right) (63233 :om-key-down) (127 :om-key-delete) (8 :om-key-delete) (3 :om-key-enter) (13 :om-key-return) (27 :om-key-esc) (9 :om-key-tab) (otherwise c))) ;; never used (defmethod om-char-callback ((self om-interactive-object) x y c modifiers) (set-meta-keys modifiers) (om-with-error-handle (om-view-key-handler self (get-om-character c))) (release-meta-keys)) ;;;===================== ;;; DECODE CHAR-SPEC ;;;===================== (defun get-om-spec-character (c) (cond ((integerp c) (get-om-character (code-char c))) ((equal :up c) :om-key-up) ((equal :down c) :om-key-down) ((equal :left c) :om-key-left) ((equal :right c) :om-key-right) ((equal :next c) :om-key-pagedown) ((equal :prior c) :om-key-pageup) ((equal :end c) :om-key-end) ((equal :home c) :om-key-home) ((equal :kp-enter c) :om-key-enter) (t nil))) (defun get-om-spec-modifiers (mod) (case mod (0 '(nil nil nil)) (1 '(t nil nil)) ; SHIFT (2 '(nil nil nil)) ; CTRL (3 '(t nil nil)) ; CTRL + SHIFT (4 '(nil nil t)) ; ALT (5 '(t nil t)) ; ALT + SHIFT (6 '(nil nil t)) ; ALT + CTRL (7 '(t nil t)) ; ALT + SHIFT + CTRL (8 '(nil t nil)) ; CMD ? (9 '(t t nil)) ; CMD + SHIFT (10 '(nil t nil)) ; CMD + CTRL (11 '(t t nil)) ; CMD + CTRL + SHIFT (12 '(nil t t)) ; CMD + ALT (13 '(t t t)) ; CMD + ALT + SHIFT (14 '(nil t t)) ; CMD + ALT + CTRL (15 '(t t t)) ; CMD + ALT + CTRL + SHIFT (otherwise '(nil nil nil)))) (defvar *om-shift-key-p* nil) (defvar *om-command-key-p* nil) (defvar *om-option-key-p* nil) ;;; LIST = SHIFT - CMD - ALT (defun set-meta-keys (list) (setf *om-shift-key-p* (first list)) (setf *om-command-key-p* (second list)) (setf *om-option-key-p* (third list))) (defun release-meta-keys () (setf *om-shift-key-p* nil) (setf *om-command-key-p* nil) (setf *om-option-key-p* nil)) (defun om-shift-key-p () *om-shift-key-p* ) (defun om-command-key-p () *om-command-key-p*) (defun om-option-key-p () *om-option-key-p*) (defmethod om-char-spec-callback ((self om-interactive-object) x y spec) (let ((data (sys:gesture-spec-data spec)) (modifiers (sys:gesture-spec-modifiers spec))) (set-meta-keys (get-om-spec-modifiers modifiers)) (om-view-key-handler self (get-om-spec-character data)) (release-meta-keys) t)) ;;; Exported callback (defmethod om-view-key-handler ((self t) key) (declare (ignore key)) nil) ;;; by default the key actions are transferred to the window ;;; but any active view can redefine the method (defmethod om-view-key-handler ((self om-graphic-object) key) (om-view-key-handler (om-view-window self) key))

Common Lisp

.lisp

cac-t-u-s/om-sharp

GPL-3.0

9/19/2024, 11:25:22 AM (Europe/Amsterdam)

882e50b937d09346980d6fa8a0aea4b010ade14e8dcd63f8155e0e386cf0b28a

tooltips.lisp

cac-t-u-s_om-sharp/src/api/om-api-LW/tooltips.lisp

;========================================================================= ; OM API ; Multiplatform API for OpenMusic ; LispWorks Implementation ;========================================================================= ; ; This program 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. ; ; This program 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 this program. If not, see <http://www.gnu.org/licenses/>. ; ;========================================================================= ; Authors: J. Bresson, C. Agon ;========================================================================= ;=========================================================================== ; TOOLTIPS ;=========================================================================== ;;; NOT USED.... (in-package :om-api) ;========== ; export : ;========== (export '( om-tt-view om-show-tooltip om-hide-tooltip ) :om-api) ;====================== (in-package :oa) #| ;;; WE DON'T USE THIS SYSTEM (defmethod handle-tooltips-in-motion ((self t) position) nil) (defmethod handle-tooltips-in-motion ((self om-view) position) (when (om-command-key-p) (let ((po (capi::pinboard-object-at-position self (om-point-x position) (om-point-y position)))) (if po (let ((text (and (help-string po) (not (string-equal (help-string po) "")) ;(reduce #'(lambda (val segment) (concatenate 'string val segment (string #\Newline))) ; (oa::text-wrap-pix (help-string po) (om-def-font :normal) 200) ; :initial-value "") (help-string po) ))) (when text (capi:display-tooltip self :x (+ (om-point-x (om-view-position po)) 10) :y (- (om-point-y (om-view-position po)) 10) :text text) )) (capi:display-tooltip self))))) (defmethod om-show-tooltip ((self om-graphic-object) &optional (remove nil) (short nil)) (when (om-get-view self) (internal-show-tooltip self remove short))) (defmethod internal-show-tooltip ((self om-graphic-object) &optional (remove nil) (short nil)) (if (and (help-string self) (not (string-equal (help-string self) "")) t) (let ((text (reduce #'(lambda (val segment) (concatenate 'string val segment (string #\Newline))) (oa::text-wrap-pix (help-string self) (om-def-font :normal) 200) :initial-value ""))) (if short (setf text (string-downcase (read-from-string text))) (setf text (subseq text 0 (- (length text) 1)))) (multiple-value-bind (x y) (capi::current-pointer-position :relative-to (om-get-view self)) (capi:display-tooltip (om-get-view self) :x x :y (- y 20) :text text) #+cocoa(sleep (if remove 0.05 0.1)) )) (capi:display-tooltip (om-get-view self)) )) ;; protect, e.g. om-tab-layout (defmethod om-hide-tooltip ((self t)) nil) (defmethod om-hide-tooltip ((self capi::output-pane)) (when (om-get-view self) (capi:display-tooltip (om-get-view self)))) |# ;;; NOT USED ;;; WORKS ONY FOR DIALOG ITEMS ;(defmethod om-help-callback ((interface om-abstract-window) pane type key) ; (when (and *helpon* (om-command-key-p)) ; (multiple-value-bind (x y) (capi::current-pointer-position :relative-to pane) ; (let ((hview (or (capi::pinboard-object-at-position pane x y) pane))) ; (case type ; (:tooltip (help-spec hview)) ; (t nil) ; ))))) ; (:pointer-documentation-enter ; (when (stringp key) ; (setf (capi:titled-object-message interface) ; key))) ; (:pointer-documentation-leave ; (setf (capi:titled-object-message interface) ; "Something else")) ; (:help (do-detailed-help interface ))) ;;;================================================ ;;; CUSTOM TOOLTIP SYSTEM ;;;================================================ (defvar *tt-process* nil) (defparameter *tt-font* (om-def-font :small-b)) ; :face "Calibri"))) ;;; call by OM-API motion handler (defmethod handle-tooltips-in-motion ((self t) position) nil) ;;; a mixing superclass for views that can display tooltips (defclass om-tt-view (om-transient-drawing-view) ((tt :accessor tt :initform nil) (ttx :accessor ttx :initform 0) (tty :accessor tty :initform 0) (ttw :accessor ttw :initform 0) (tth :accessor tth :initform 0))) (defmethod om-show-tooltip ((view t) text &optional pos delay) nil) (defmethod om-hide-tooltip ((view t)) nil) (defun tooltip-draw (view) (oa::om-with-focused-view view (om-with-fg-color (om-make-color 0. 0. 0. 0.5) (om-draw-rect (ttx view) (tty view) (ttw view) (tth view) :fill t)) (om-with-fg-color (om-make-color 1 1 1) (om-with-font *tt-font* (if (listp (tt view)) (loop for line in (tt view) for n = (+ (tty view) 12) then (+ n 12) do (om-draw-string (+ (ttx view) 5) n line)) (om-draw-string (+ (ttx view) 5) (+ (tty view) 12) (tt view)) ) )) )) (defmethod om-show-tooltip ((view om-tt-view) text &optional pos (delay 0.3)) (when *tt-process* (om-kill-process *tt-process*)) (let ((pp (or pos (om-add-points (om-mouse-position view) (om-make-point 0 -25))))) (setf *tt-process* (om-run-process "tooltip" #'(lambda () (sleep delay) (setf (tt view) text (ttx view) (om-point-x pp) (tty view) (om-point-y pp) (ttw view) (+ 20 (if (listp text) (loop for line in text maximize (om-string-size line *tt-font*)) (om-string-size text *tt-font*))) (tth view) (+ 6 (* 12 (if (listp text) (length text) 1))) ) (capi::apply-in-pane-process view #'(lambda () (om-start-transient-drawing view #'(lambda (view position size) (declare (ignore position size)) (tooltip-draw view)) pp (omp (ttw view) (tth view))))) ;(capi::apply-in-pane-process view 'om-invalidate-view 'tooltip-draw view) ))) )) (defmethod om-hide-tooltip ((view om-tt-view)) (when (and view (tt view)) (om-invalidate-area view (ttx view) (tty view) (+ (ttx view) (ttw view)) (+ (tty view) (tth view))) (setf (tt view) nil)) (om-stop-transient-drawing view) (when *tt-process* (om-kill-process *tt-process*) (setf *tt-process* nil)))

Common Lisp

.lisp

cac-t-u-s/om-sharp

GPL-3.0

9/19/2024, 11:25:22 AM (Europe/Amsterdam)

bb884ae1819ae9be949e4f21441638693dad441ba5c16e2e3fee08a11d2eb7d4

libraries.lisp

cac-t-u-s_om-sharp/src/api/om-api-LW/libraries.lisp

;========================================================================= ; OM API ; Multiplatform API for OpenMusic ; LispWorks Implementation ;========================================================================= ; ; This program 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. ; ; This program 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 this program. If not, see <http://www.gnu.org/licenses/>. ; ;========================================================================= ; Authors: J. Bresson, C. Agon ;========================================================================= ;;=========================================================================== ; EXTERNAL POINTERS ;;=========================================================================== (in-package :oa) ; (setq fli::*default-dlflags* 6) ; (setq fli::*can-use-dlopen* nil) ;;;==================================== ;;; POINTERS ;;;==================================== (export '(om-alloc-memory om-free-memory om-free-pointer om-read-ptr om-write-ptr om-make-null-pointer om-null-pointer-p om-pointer-equal om-cleanup-mixin om-cleanup om-create-with-gc ) :om-api) (defun om-make-null-pointer () (fli:make-pointer :address 0 :type :void)) (defun om-alloc-memory (size &key (type :byte) (clear nil)) (if clear (fli:allocate-foreign-object :type type :nelems size :fill 0) (fli:allocate-foreign-object :type type :nelems size))) (defun om-free-memory (ptr) (fli::free-foreign-object ptr)) ;;; !!! does not work very well: crashes a lot on Mac, e.g. with SDIF files ;(defun om-write-ptr (ptr pos type value) ; (setf (fli:dereference ptr :type type :index pos) value)) ; => inspired from CFFI (defun om-write-ptr (ptr pos type value) (locally (declare (optimize (speed 3) (safety 0))) (setf (fli:foreign-typed-aref type ptr (the fixnum pos)) value))) (defun om-read-ptr (ptr pos type) (fli:dereference ptr :type type :index pos)) (defun om-null-pointer-p (ptr) ;(check-type ptr fli::pointer) (fli:null-pointer-p ptr)) (defun om-pointer-equal (ptr1 ptr2) ;(check-type ptr fli::pointer) (fli:pointer-eq ptr1 ptr2)) #| ;; redefinitions using CFFI ;; previously cffi::%mem-set (defun om-write-ptr (ptr pos type value) (cffi::mem-set value ptr type pos)) ;; previously cffi::%mem-ref ;; previously cffi::mem-ref (defun om-read-ptr (ptr pos type) (cffi::mem-aref ptr type pos)) ;(setf aaa (om-make-pointer 5)) ;(om-write-ptr aaa 1 :float 8.0) ;(om-read-ptr aaa 0 :float) |# ;;;======================== ;;; A POINTER STRUCT WITH COUNTER ;;;======================== (defstruct om-pointer (ptr) (size) (count 0 :type integer)) (defun om-pointer-get-ptr (om-pointer) (om-pointer-ptr om-pointer)) ;;; can be redefined for subtypes of om-pointer (defmethod om-pointer-release-function ((self om-pointer)) 'om-free-pointer) (defmethod om-free-pointer ((self om-pointer)) (om-free-memory (om-pointer-ptr self))) (defmethod om-retain ((omptr om-pointer)) (setf (om-pointer-count omptr) (1+ (om-pointer-count omptr)))) (defmethod om-release ((omptr om-pointer)) (setf (om-pointer-count omptr) (1- (om-pointer-count omptr))) (when (<= (om-pointer-count omptr) 0) (funcall (om-pointer-release-function omptr) omptr))) ;;;======================== ;;; CLEANUP/DEALLOC UTILS ;;;======================== (hcl::add-special-free-action 'om-cleanup) ;;; FOR CLASSES ;;; to be subclassed by special-cleanup objects (defclass om-cleanup-mixin () ()) ;;; FOR STRUCTS (defmacro om-create-with-gc (&body body) `(let ((object ,@body)) ;(print (list "FLAG CLEANUP FOR" object)) (hcl::flag-special-free-action object) object)) (defmethod initialize-instance :before ((self om-cleanup-mixin) &rest args) ;(print (list "FLAG CLEANUP FOR" self)) (hcl::flag-special-free-action self)) ;;; to be redefined for specific om-cleanup-mixin subclasses (defmethod om-cleanup ((self t)) nil)

Common Lisp

.lisp

cac-t-u-s/om-sharp

GPL-3.0

9/19/2024, 11:25:22 AM (Europe/Amsterdam)

4ee2e66c3092f01b19d247f114d85b4e34b867ae82727f576a7ec93058dce7e1

graphic-object.lisp

cac-t-u-s_om-sharp/src/api/om-api-LW/graphic-object.lisp

;========================================================================= ; OM API ; Multiplatform API for OpenMusic ; LispWorks Implementation ;========================================================================= ; ; This program 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. ; ; This program 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 this program. If not, see <http://www.gnu.org/licenses/>. ; ;========================================================================= ; Authors: J. Bresson, C. Agon ;========================================================================= ;=========================================================================== ; GRAPHIC OBJECT SUPERCLASS AND METHODS ;=========================================================================== (in-package :om-api) ;;;===================== ;;; export : ;;;===================== (export '( om-graphic-object om-make-graphic-object om-initialized-p om-width om-height om-view-size om-view-position om-set-view-size om-set-interior-size om-set-view-position om-change-view-position om-set-bg-color om-get-bg-color om-set-fg-color om-get-fg-color om-get-font om-set-font om-set-focus om-get-name om-view-window om-view-container om-subviews om-add-subviews om-remove-subviews om-with-delayed-update ) :om-api) ;;;===================== ;;;======================= ;;; GENERAL GRAPHIC OBJECT ;;;======================= ;;; EQUIVALENT SIMPLE-PANE IN LISPWORK/CAPI ;;; manages general callbacks and behaviors (defclass om-graphic-object () ((vcontainer :initform nil :initarg :vcontainer :accessor vcontainer) (vsubviews :initform nil :initarg :vsubviews :accessor vsubviews) (locked :initform nil :initarg :locked :accessor locked) (vx :initform 0 :initarg :vx :accessor vx) (vy :initform 0 :initarg :vy :accessor vy) (vw :initform 32 :initarg :vw :accessor vw) (vh :initform 32 :initarg :vh :accessor vh) (help-string :initform nil :initarg :help-string :accessor help-string) (initialized-p :initform nil :accessor initialized-p) )) ;;; different for om-window (defmethod om-get-view ((self t)) self) (defmethod om-get-view ((self om-graphic-object)) self) (defmethod om-subviews ((self om-graphic-object)) (vsubviews self)) ;;; for windows, skip default window layout (defmethod container-skip-layout ((self t)) self) (defmethod om-view-container ((self om-graphic-object)) (container-skip-layout (vcontainer self))) (defmethod rec-top-level ((self t)) (if (om-view-container self) (rec-top-level (om-view-container self)) ;;;self nil )) (defmethod rec-top-level ((self capi::interface)) self) (defmethod om-view-window ((self om-graphic-object)) (let ((rep (capi::top-level-interface self))) (or rep (rec-top-level self)) )) (defmethod om-initialized-p ((self om-graphic-object)) (initialized-p self)) ;;;====================== ;;; SUBVIEW MANAGEMENT ;;;====================== (defun maybe-call-update (graphic-obj) (when (and (initialized-p graphic-obj) (not (locked graphic-obj))) (update-for-subviews-changes graphic-obj t) )) (defmethod update-for-subviews-changes ((self om-graphic-object) &optional (recursive nil)) nil) (defmacro om-with-delayed-update (view &body body) `(progn (setf (locked ,view) t) ,@body (setf (locked ,view) nil) (maybe-call-update ,view) )) (defmethod om-add-subviews ((self om-graphic-object) &rest subviews) "Adds subviews to a graphicbject" (loop for item in subviews do (internal-add-subview self item)) (maybe-call-update self) ) (defmethod internal-add-subview ((self om-graphic-object) (subview om-graphic-object)) (setf (vcontainer subview) self) (setf (vsubviews self) (append (vsubviews self) (list subview)))) (defmethod om-remove-subviews ((self om-graphic-object) &rest subviews) (capi::apply-in-pane-process (om-get-view self) #'(lambda () (loop for item in subviews do (internal-remove-subview self item)) (maybe-call-update self) ))) (defmethod om-remove-all-subviews ((self om-graphic-object)) (capi::apply-in-pane-process (om-get-view self) #'(lambda () (loop for item in (om-subviews self) do (internal-remove-subview self item)) (maybe-call-update self)))) (defmethod internal-remove-subview ((self om-graphic-object) (subview om-graphic-object)) (setf (vcontainer subview) nil) (setf (vsubviews self) (remove subview (vsubviews self)))) ;;;====================== ;;; POSITION AND SIZE ;;;====================== (defmethod om-set-view-position ((self om-graphic-object) pos-point) (capi:apply-in-pane-process self #'(lambda () (setf (capi::pinboard-pane-position self) (values (om-point-x pos-point) (om-point-y pos-point))))) ;(set-hint-table self (list :default-x (om-point-x pos-point) :default-x (om-point-y pos-point)))) (setf (vx self) (om-point-x pos-point) (vy self) (om-point-y pos-point))) (defmethod om-view-position ((self om-graphic-object)) (if (capi::interface-visible-p self) (capi:apply-in-pane-process self #'(lambda () (multiple-value-bind (x y) (capi::pinboard-pane-position self) (setf (vx self) x) (setf (vy self) y))))) (om-make-point (vx self) (vy self))) (defmethod om-set-view-size ((self om-graphic-object) size-point) (capi:apply-in-pane-process self #'(lambda () (setf (capi::pinboard-pane-size self) (values (om-point-x size-point) (om-point-y size-point))) ;; #+win32(setf (pinboard-pane-size (main-pinboard-object self)) ;; (values (om-point-x size-point) (om-point-y size-point))) )) ; (set-hint-table self (list :default-width (om-point-x size-point) :default-height (om-point-y size-point)))) (setf (vw self) (om-point-x size-point)) (setf (vh self) (om-point-y size-point))) (defmethod om-set-interior-size ((self om-graphic-object) size-point) (capi:apply-in-pane-process self #'(lambda () (capi::set-hint-table self `(:internal-min-width ,(om-point-x size-point) :internal-min-height ,(om-point-y size-point))) )) ) (defmethod om-view-size ((self om-graphic-object)) (if (capi::interface-visible-p self) (capi:apply-in-pane-process self #'(lambda () (multiple-value-bind (w h) (capi::pinboard-pane-size self) (setf (vw self) w) (setf (vh self) h))))) (om-make-point (vw self) (vh self))) (defmethod om-width ((item om-graphic-object)) (om-point-x (om-view-size item))) (defmethod om-height ((item om-graphic-object)) (om-point-y (om-view-size item))) ;;;====================== ;;; TOOLS ;;;====================== (defmethod om-view-contains-point-p ((view t) point) nil) (defmethod om-view-contains-point-p ((view om-graphic-object) point) (let* ((x (om-point-x point)) (y (om-point-y point)) (vsize (om-view-size view)) (vpos (or (om-view-position view) (om-make-point 0 0))) ) (and (om-point-x vpos) (om-point-y vpos) (om-point-x vsize) (om-point-y vsize) (> x (om-point-x vpos)) (> y (om-point-y vpos)) (< x (+ (om-point-x vpos) (om-point-x vsize))) (< y (+ (om-point-y vpos) (om-point-y vsize)))))) ;;; capi::pinboard-object-at-position (defun om-find-view-containing-point (view point &optional (recursive t)) (if view (let ((subviews (om-subviews view))) (do ((i (- (length subviews) 1) (- i 1))) ((< i 0)) (let ((subview (nth i subviews))) (when (om-view-contains-point-p subview point) (return-from om-find-view-containing-point (progn (when recursive (om-find-view-containing-point subview (om-convert-coordinates point view subview)))) )))) view))) ;;; capi::convert-relative-position (defun om-convert-coordinates (point view1 view2) (if (and view1 view2) (om-add-points point (om-subtract-points (om-view-origin view2) (om-view-origin view1))) (progn (print (format nil "Warning: Can not convert position with NULL views: ~A, ~A." view1 view2)) point))) (defun om-view-origin (view) (let ((container (om-view-container view))) (if container (let ((position (om-view-position view)) (container-origin (om-view-origin container))) (if position (om-subtract-points container-origin position) container-origin)) (om-make-point 0 0) ))) ; (capi:map-pane-descendant-children layout ; #'(lambda (p) (when (capi:pane-has-focus-p p) (return-from find-pane-with-focus p))))) (defun om-get-subview-with-focus (view) (capi::pane-descendant-child-with-focus view)) (defmethod om-set-bg-color ((self om-graphic-object) color) (let ((col (when color (omcolor-c color)))) #-cocoa (if (and col (equal col :transparent) (om-view-container self)) (capi::simple-pane-background (om-get-view self) NIL) (setf (capi::simple-pane-background (om-get-view self)) col)) #+cocoa (setf (capi::simple-pane-background (om-get-view self)) col))) (defmethod om-get-bg-color ((self om-graphic-object)) (let ((c (capi::simple-pane-background (om-get-view self)))) (when (and c (not (equal c :transparent))) (make-omcolor :c c)))) (defmethod om-set-fg-color ((self om-graphic-object) color) (let ((col (when color (omcolor-c color)))) (capi::apply-in-pane-process self #'(lambda () (setf (capi::simple-pane-foreground (om-get-view self)) col)) ))) (defmethod om-get-fg-color ((self om-graphic-object)) (make-omcolor :c (capi::simple-pane-foreground (om-get-view self)))) (defmethod om-get-font ((self om-graphic-object)) (let ((font (capi::simple-pane-font self))) (if (gp::font-description-p font) font (gp::font-description font)))) (defmethod om-set-font ((self t) font) (print (format nil "WARNING NO METHOD DEFINED TO SET FONT WITH ~A" self)) NIL) (defmethod om-set-font ((self capi::simple-pane) font) (setf (capi::simple-pane-font self) font)) (defmethod om-set-focus ((self om-graphic-object)) (capi::set-pane-focus self)) (defmethod om-get-name ((self om-graphic-object)) (capi::capi-object-name self))

Common Lisp

.lisp

cac-t-u-s/om-sharp

GPL-3.0

9/19/2024, 11:25:22 AM (Europe/Amsterdam)

570c6c19c6e405e7a5a4ddc77663aecafeeb5b474fe44b8187ce5e9e397baf8d

om-special.lisp

cac-t-u-s_om-sharp/src/api/om-api-LW/om-special.lisp

;========================================================================= ; OM API ; Multiplatform API for OpenMusic ; LispWorks Implementation ;========================================================================= ; ; This program 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. ; ; This program 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 this program. If not, see <http://www.gnu.org/licenses/>. ; ;========================================================================= ; Authors: J. Bresson, C. Agon ;========================================================================= ;=========================================================================== ; SPECIAL OPENMUSIC FUNCTIONS ;=========================================================================== (in-package :om-api) (export '( om-special-lisp-form-p om-root-folder om-set-root-folder om-resources-folder om-inspect ) :om-api) ;;; types of functions that are not accepted as OM boxes (defun om-special-lisp-form-p (symbol) (or (lispworks::special-form-p symbol) #+macosx(and (fboundp symbol) ;;; what is this for... ? (system:closurep (fdefinition symbol))) )) ;======================= ; SOURE MANAGEMENT ;======================= (defparameter *om-root* cl-user::*om-root-directory*) (defun om-root-folder () *om-root*) (defun om-set-root-folder (path) (setf *om-root* path)) (defun om-resources-folder () #+macosx (if (oa::om-standalone-p) (make-pathname :host (pathname-host (oa::om-lisp-image)) :device (pathname-device (oa::om-lisp-image)) :directory (append (butlast (pathname-directory (oa::om-lisp-image))) '("Resources"))) (make-pathname :host (pathname-host (oa::om-root-folder)) :device (pathname-device (oa::om-root-folder)) :directory (append (pathname-directory (oa::om-root-folder)) '("resources")))) #+linux (if (oa::om-standalone-p) (make-pathname :host (pathname-host (oa::om-lisp-image)) :device (pathname-device (oa::om-lisp-image)) :directory (append (butlast (pathname-directory (oa::om-lisp-image))) '("share" "om-sharp" "resources"))) (make-pathname :host (pathname-host (oa::om-root-folder)) :device (pathname-device (oa::om-root-folder)) :directory (append (pathname-directory (oa::om-root-folder)) '("resources")))) #+win32 (make-pathname :host (pathname-host (oa::om-root-folder)) :device (pathname-device (oa::om-root-folder)) :directory (append (pathname-directory (oa::om-root-folder)) '("resources"))) ) ;======================= ; INSPECTOR ;======================= (defclass inspect-dialog (om-dialog) ((object :initarg :object :initform nil :accessor object) (parents :initform nil :accessor parents) (list1 :initform nil :accessor list1) (list2 :initform nil :accessor list2) (selected-item :initform nil :accessor selected-item) (parent-button :initform nil :accessor parent-button) (parent-label :initform nil :accessor parent-label))) (defun decompose-object (obj) (cond ((consp obj) (if (listp (cdr obj)) (loop for item in obj for i = 0 then (+ i 1) collect (list i item)) (list (list "car" (car obj)) (list "cdr" (cdr obj))))) ((arrayp obj) (loop for i = 0 then (+ i 1) while (< i (length obj)) collect (list i (aref obj i)))) ((structurep obj) (loop for sl in (structure::structure-class-slot-names (find-class (type-of obj) nil)) collect (list sl (slot-value obj sl)))) ((and (find-class (type-of obj) nil) (hcl::class-slots (find-class (type-of obj)))) (loop for slot in (hcl::class-slots (find-class (type-of obj))) collect (list (hcl::slot-definition-name slot) (if (hcl::slot-boundp obj (hcl::slot-definition-name slot)) (slot-value obj (hcl::slot-definition-name slot)) :unbound)))) ((atom obj) (list obj)) (t nil))) (defun set-inspector-panel (item-list object) (setf (capi::collection-items item-list) (loop for elt in (decompose-object object) collect (if (consp elt) (concatenate 'string (string-upcase (format nil "~A" (car elt))) (format nil ": ~A" (cadr elt))) (format nil "~A" elt))))) (defmethod set-selected-item ((win inspect-dialog) selected-value) (setf (selected-item win) selected-value) (set-inspector-panel (list2 win) (selected-item win))) (defmethod set-inspected-object ((win inspect-dialog) name value) (om-set-window-title win (format nil "Inspecting ~A" (if (numberp name) value name))) (setf (object win) value) (set-inspector-panel (list1 win) value) (set-selected-item win (cadr (car (decompose-object value)))) (om-set-dialog-item-text (parent-label win) (format nil "Parent: ~A" (car (parents win)))) (om-enable-dialog-item (parent-button win) (parents win))) (defmethod initialize ((self inspect-dialog)) (setf (list1 self) (om-make-di 'om-single-item-list :size (om-make-point nil 260) :focus nil :scrollbars :v :callback-type '(:collection) :test-function 'string-equal :range nil :action-callback #'(lambda (list) (let* ((selection (nth (capi::choice-selection list) (decompose-object (object self)))) (selection-name (car selection)) (selection-value (cadr selection))) (when (consp (car (decompose-object selection-value))) (push (object self) (parents self)) (set-inspected-object self selection-name selection-value) ))) :selection-callback #'(lambda (list) (let ((selection (nth (capi::choice-selection list) (decompose-object (object self))))) (set-selected-item self (cadr selection)))) )) (setf (list2 self) (om-make-di 'om-single-item-list :size (om-make-point nil 260) :focus nil :scrollbars :v :callback-type '(:collection) :test-function 'string-equal :range nil :action-callback #'(lambda (list) (let ((selection (nth (capi::choice-selection list) (decompose-object (selected-item self))))) (when (consp selection) (let ((selection-name (car selection)) (selection-value (cadr selection))) (when (consp (car (decompose-object selection-value))) (push (object self) (parents self)) (push (selected-item self) (parents self)) (set-inspected-object self selection-name selection-value) ))) )) )) (setf (parent-button self) (om-make-di 'om-button :size (omp 40 24) :text "<" :di-action #'(lambda (button) (declare (ignore button)) (set-inspected-object self 0 (pop (parents self)))) )) (setf (parent-label self) (om-make-di 'om-simple-text :size (omp nil 16))) (om-add-subviews self (om-make-layout 'om-column-layout :delta 6 :subviews (list (om-make-layout 'om-row-layout :align :center :subviews (list (parent-button self) (parent-label self))) (om-make-layout 'om-row-layout :subviews (list (list1 self) (list2 self)))))) ) (defun om-inspect (object &optional position) (let* ((win (om-make-window 'inspect-dialog :object object :size (omp 400 nil) :position (or position (om-make-point 200 200)) :resizable t :win-layout 'om-simple-layout :menu-items (list (om-make-menu "File" (list (om-make-menu-item "Close all inspector windows" #'(lambda () (mapc 'om-close-window (om-get-all-windows 'inspect-dialog))) :key "w")))) ))) (initialize win) (set-inspected-object win 0 object) (om-select-window win)))

Common Lisp

.lisp

cac-t-u-s/om-sharp

GPL-3.0

9/19/2024, 11:25:22 AM (Europe/Amsterdam)

a101f317f4a5fe03fb8d37cf3e860759157839d83d4d6807723c78a7fc784cef

draw.lisp

cac-t-u-s_om-sharp/src/api/om-api-LW/draw.lisp

;========================================================================= ; OM API ; Multiplatform API for OpenMusic ; LispWorks Implementation ;========================================================================= ; ; This program 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. ; ; This program 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 this program. If not, see <http://www.gnu.org/licenses/>. ; ;========================================================================= ; Authors: J. Bresson, C. Agon ;========================================================================= ;========================================================================= ; OM-GRAPHIC OBJECTS DISPLAY CALLBACKS ;========================================================================= (export '( om-draw-string om-draw-char om-draw-line om-draw-lines om-draw-dashed-line om-draw-rect om-draw-rounded-rect om-draw-ellipse om-draw-arc om-draw-circle om-draw-polygon om-draw om-with-focused-view om-with-fg-color om-with-bg-color om-with-font om-with-line-size om-with-line om-with-translation om-with-alpha om-with-delayed-redraw om-with-clip-rect om-draw-contents om-draw-contents-area om-invalidate-view om-invalidate-area ) :om-api) (in-package :om-api) ;;;====================== ;;; SPECIFIC OPERATIONS ON GRAPHIC STATE ;;;====================== (defvar *curstream* nil) (defvar *alpha* nil) ; formerly if (om-item-view-p ,view) ; => (multiple-value-bind (*pox* *poy*) (capi::pinboard-pane-position ,view) ,@body) (defmacro om-with-focused-view (view &body body) (declare (special *curstream*)) `(let ((*curstream* (om-get-view ,view))) (when *curstream* ,@body))) (defmacro om-with-alpha (a &body body) `(let ((*alpha* ,a)) ,@body)) (defun get-real-color (omcolor) (when omcolor (if *alpha* (color::color-with-alpha (omcolor-c omcolor) *alpha*) (omcolor-c omcolor)))) (defmacro om-with-fg-color (color &body body) `(if ,color (gp::with-graphics-state (*curstream* :foreground (get-real-color ,color)) ,@body) (progn ,@body))) (defmacro om-with-bg-color (color &body body) `(gp::with-graphics-state (*curstream* :background (get-real-color ,color)) ,@body)) (defmacro om-with-font (font &rest body) `(gp::with-graphics-state (*curstream* :font (if (gp::font-description-p ,font) (gp::find-best-font *curstream* ,font) ,font)) ,@body)) (defmacro om-with-line (style &body body) `(cond ((consp ,style) (gp::with-graphics-state (*curstream* :dashed t :dash (list (car ,style) (cadr ,style))) ,@body)) ((equal ,style :dash) (gp::with-graphics-state (*curstream* :dashed t :dash '(2 2)) ,@body)) (t (progn ,@body)))) (defmacro om-with-line-size (size &body body) `(let ((siz #+cocoa ,size #-cocoa (max 1 (round ,size)))) (gp::with-graphics-state (*curstream* :thickness siz :line-joint-style :miter ; :bevel :round :line-end-style :butt) ; :butt :projecting ,@body))) (defvar *translation* (omp 0 0)) (defmacro om-with-translation (x y &body body) (declare (special *translation*)) `(gp::with-graphics-transform (*curstream* (gp::apply-translation (gp::make-transform) ,x ,y)) (let ((*translation* (omp ,x ,y))) ,@body))) ;;;===================== ;;; CALLBACKS / INVALIDATE ;;;===================== ;;; do not define both of them ! (defmethod om-draw-contents ((self om-graphic-object)) t) (defmethod om-draw-contents-area ((self om-graphic-object) x y w h) (om-draw-contents self)) (defmethod om-draw-contents-callback ((self t) x y w h) nil) (defmethod om-draw-contents-callback ((self om-graphic-object) x y w h) (call-next-method) (gp::set-graphics-port-coordinates (om-get-view self) :left 0 :top 0) (om-with-focused-view self ;(oa::om-with-clip-rect self 0 0 (vw self) (vh self) ;;; removed from draw-contents for windows d&d... ;(capi::apply-in-pane-process (om-get-view self) 'om-draw-contents self)) ;(gp::with-graphics-state ((om-get-view self) :mask (list 0 0 (vw self) (vh self))) (om-draw-contents-area self x y w h) ;(om-draw-contents self) (mapcar #'(lambda (po) (when (capi::pinboard-object-overlap-p po x y (+ x w) (+ y h)) (capi::draw-pinboard-object (om-get-view self) po :x (item-x po) :y (item-y po) :width (vw po) :height (vh po)) )) (item-subviews (om-get-view self))) ) ) ;;; ONLY FOR WINDOWS ;;; draws a pinboard-object on top of the layout ;(defmethod capi::draw-pinboard-object (pane (po om-view-pinboard-object) &key x y w h) ; (declare (ignore x y w h)) ; (capi::apply-in-pane-process pane #'(lambda (pa) ; ;(let ((posx (or (capi::get-horizontal-scroll-parameters pa :slug-position) 0)) ; ; (posy (or (capi::get-vertical-scroll-parameters pa :slug-position) 0))) ; ;(om-with-delayed-redraw ; (om-with-focused-view pa (om-draw-contents pa)) ; ; )) ; ) pane)) (defmethod om-invalidate-view ((self t)) nil) (defmethod om-invalidate-view ((self om-graphic-object)) (when (and (capi::interface-visible-p self) (om-get-view self)) (capi::with-atomic-redisplay ((om-get-view self)) (capi::apply-in-pane-process (om-get-view self) 'internal-invalidate-view (om-get-view self))))) (defmethod internal-invalidate-view ((self om-view)) (gp::invalidate-rectangle (om-get-view self)) #+windows(mapc 'internal-invalidate-view (om-subviews self))) (defmethod om-invalidate-view ((self om-abstract-window)) (capi::with-atomic-redisplay ((om-get-view self)) (capi::execute-with-interface self 'internal-invalidate-view (om-get-view self)))) (defmethod internal-invalidate-view ((self om-abstract-layout)) (mapc 'internal-invalidate-view (capi::layout-description self))) (defmethod internal-invalidate-view ((self t)) nil) (defmethod om-invalidate-area ((self om-graphic-object) x1 y1 x2 y2) (when (and (capi::interface-visible-p self) (om-get-view self)) (capi::with-atomic-redisplay ((om-get-view self)) (capi::apply-in-pane-process (om-get-view self) 'gp::invalidate-rectangle (om-get-view self) (min x1 x2) (min y1 y2) (abs (- x2 x1)) (abs (- y2 y1))) ;#+win32(mapcar 'om-invalidate-view (om-subviews self)) ))) (defmacro om-with-delayed-redraw (view &body body) `(capi:with-atomic-redisplay (,view) ,@body)) ;;; nouveau.. (defmethod om-redraw-view ((self om-graphic-object)) (capi:redraw-pinboard-layout (om-get-view self) 0 0 (om-width self) (om-height self) t)) ;;;====================== ;;; DRAW SHAPES ;;;====================== (defun format-line-style (style) (cond ((consp style) `(:dashed t :dash (,(car style) ,(cadr style)))) ((equal style :dash) '(:dashed t :dash (2 2))) (style '(:dashed nil)) ;; unknow or nil (t nil))) (defun format-graphic-args (&key fcolor bcolor line style) (reduce 'append (remove nil (list (when fcolor (list :foreground (get-real-color fcolor))) (when bcolor (list :background (get-real-color bcolor))) (when line (list :thickness line)) (when style (format-line-style style)) )) )) (defun om-draw-char (x y char &key font color) (apply 'gp:draw-character (append (list *curstream* char x y) (when color `(:foreground ,(get-real-color color))) (when font `(:font ,(gp::find-best-font *curstream* font))) ))) (defun om-draw-string (x y str &key selected wrap font align color) (if wrap (let* ((real-font (if font (gp::find-best-font *curstream* font) (gp::get-port-font *curstream*))) (wrap-w (max wrap (multiple-value-bind (left top right bottom) (gp::get-string-extent *curstream* "--" real-font) (- right left))))) (multiple-value-bind (left top right bottom) (gp::get-string-extent *curstream* str real-font) (declare (ignore left right)) (let ((text-list (or (ignore-errors (capi::wrap-text-for-pane *curstream* str ;; (substitute #\Space #\Tab str) :visible-width wrap-w :font real-font )) (list str))) (text-h (- bottom top))) (loop for line in text-list for yy = y then (+ yy text-h) do (let ((xx (if align (multiple-value-bind (left top right bottom) (gp::get-string-extent *curstream* line real-font) (declare (ignore top bottom)) (let ((line-w (- right left))) (cond ((equal align :right) (+ x wrap-w (- line-w))) ((equal align :center) (+ x (round wrap-w 2) (- (round line-w 2)))) (t x)))) x))) (apply 'gp:draw-string (append (list *curstream* line xx #+mswindows (- yy 1) #-mswindows yy :text-mode :default) (if selected '(:block t :foreground :color_highlighttext :background :color_highlight) (if color `(:block nil :foreground ,(get-real-color color)) '(:block nil))) (when font `(:font ,real-font)))) )) )) ) (apply 'gp:draw-string (append (list *curstream* str ;; (substitute #\Space #\Tab str) x #+mswindows (- y 1) #-mswindows y :text-mode :default) (if selected '(:block t :foreground :color_highlighttext :background :color_highlight) (if color `(:block nil :foreground ,(get-real-color color)) '(:block nil))) (when font `(:font ,(gp::find-best-font *curstream* font))) )) )) ;; #-cocoa :operation #-cocoa (if erasable boole-eqv boole-1) ;; end-style = :round or :projecting (defun om-draw-line (x1 y1 x2 y2 &key color line style (end-style :round)) (apply 'gp:draw-line (cons *curstream* (append (if (and line (integerp line) (oddp line)) (list (+ x1 0.5) (+ y1 0.5) (+ x2 0.5) (+ y2 0.5)) (list x1 y1 x2 y2)) `(:line-end-style ,end-style) (format-graphic-args :fcolor color :line line :style style) )) )) (defun om-draw-dashed-line (x1 y1 x2 y2) (gp:draw-line *curstream* x1 y1 x2 y2 :dashed t) ; :round or :projecting) ) (defun om-draw-lines (list-of-x-y) (gp:draw-lines *curstream* list-of-x-y)) (defun convert-rect (x y w h) (values (if (minusp w) (+ x w) x) (if (minusp h) (+ y h) y) (abs w) (abs h))) (defun om-draw-rect (x y w h &key angles line color fill style) (multiple-value-bind (xx yy ww hh) (convert-rect x y w h) (apply 'gp:draw-rectangle (append (list *curstream* (+ xx 0.5) (+ yy 0.5) (- ww 1) (- hh 1) :filled fill :line-joint-style angles ; :bevel :miter :round :thickness line :foreground (get-real-color color)) (format-line-style style) )))) (defun om-draw-rounded-rect (x y w h &key (round 10) line color fill style) (multiple-value-bind (xx yy ww hh) (convert-rect x y w h) (apply 'gp:draw-path (append (list *curstream* `((:move ,round 0) (:line ,(- ww round) 0) (:arc ,(- ww (* 2 round) 2) 0 ,(* round 2) ,(* round 2) ,(/ pi 2) ,(/ pi -2) nil) (:line ,(- ww 2) ,(- hh round)) (:arc ,(- ww (* 2 round) 2) ,(- hh (* 2 round) 1) ,(* round 2) ,(* round 2) 0 ,(/ pi -2) nil) (:line ,round ,(- hh 1)) (:arc 1 ,(- hh (* 2 round) 1) ,(* round 2) ,(* round 2) ,(/ pi -2) ,(/ pi -2) nil) (:line 1 ,round) (:arc 1 0 ,(* round 2) ,(* round 2) ,pi ,(/ pi -2) nil) ) (+ xx 0.5) (+ yy 0.5) :filled fill :closed fill :thickness line :foreground (get-real-color color)) (format-line-style style) ) ))) (defun om-draw-ellipse (x y rx ry &key fill) (gp:draw-ellipse *curstream* x y rx ry :filled fill)) (defun om-draw-arc (x y width height start-angle sweep-angle) (gp::draw-arc *curstream* x y width height start-angle sweep-angle)) (defun om-draw-circle (x y r &key fill color) (gp::draw-circle *curstream* x y r :filled fill :foreground (get-real-color color))) (defun om-draw-polygon (points &key fill) (gp:draw-polygon *curstream* (cond ((om-point-p (car points)) (mapcan #'(lambda (p) (list (om-point-x p) (om-point-y p))) points)) ((listp (car points)) (apply #'append points)) (t points)) :closed t :filled fill)) (defun om-draw (points &key color line style) (apply 'gp:draw-polygon (append (list *curstream* (cond ((om-point-p (car points)) (loop for item in points append (list (om-point-x item) (om-point-y item)))) ((listp (car points)) (loop for item in points append item)) (t points)) :closed nil :filled nil ;:shape-mode :plain ) (format-graphic-args :fcolor color :line line :style style)))) (defmethod position-in-view ((self om-view)) (omp 0 0)) ;;; drag and drop creates temporary view clones and might require that (defvar *override-clipping-shift* nil) (defmethod clipping-shift ((self om-view)) (omp 0 0)) (defmacro om-with-clip-rect (view x y w h &body body) `(let ((shift (if *override-clipping-shift* (om-add-points (clipping-shift (om-get-view ,view)) *translation*) (position-in-view ,view)))) (gp::with-graphics-state ((om-get-view ,view) :mask (list (+ (om-point-x shift) ,x) (+ (om-point-y shift) ,y) ,w ,h)) ,@body)))

Common Lisp

.lisp

cac-t-u-s/om-sharp

GPL-3.0

9/19/2024, 11:25:22 AM (Europe/Amsterdam)

634298612fcbeb6712c2ef29fa6a55b7e98aafda14b197e604c3904039c633f7

draganddrop.lisp

cac-t-u-s_om-sharp/src/api/om-api-LW/draganddrop.lisp

;========================================================================= ; OM API ; Multiplatform API for OpenMusic ; LispWorks Implementation ;========================================================================= ; ; This program 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. ; ; This program 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 this program. If not, see <http://www.gnu.org/licenses/>. ; ;========================================================================= ; Authors: J. Bresson, C. Agon ;========================================================================= ;========================================================================= ; DRAG AND DROP ;========================================================================= (in-package :om-api) (export '( om-drag-view om-drop-view om-drag-start om-drag-receive om-drag-enter-view om-drag-leave-view om-drag-area om-draw-contents-for-drag om-import-files-in-app om-drag-string-in-app ) :om-api) ;;;================== ;;; DRAG/DROP VIEW ;;;================== (defclass om-drag-view () ((cursor-pos :initform (om-make-point 0 0) :accessor om-drag-view-cursor-pos))) (defmethod om-drag-view-p ((self t)) nil) (defmethod om-drag-view-p ((self om-drag-view)) t) ;;; called before drag: must return T or drag will not start (defmethod om-drag-start ((self om-drag-view) pos) t) (defclass om-drop-view () ((drag-image :initform nil :accessor drag-image)) (:default-initargs :drop-callback 'om-drop-callback)) (defmethod om-drop-view-p ((self t)) nil) (defmethod om-drop-view-p ((self om-drop-view)) t) (defmethod om-draw-contents-for-drag ((self om-drag-view)) (om-draw-contents self)) ;;; redefines from draw.lisp, to override default clipping ;;; if necessary (see bbelow for windows) (defmethod clipping-shift :around ((self om-drop-view)) (if (drag-image self) (om-view-position (drag-image self)) (omp 0 0))) (defmethod om-drag-area ((self om-drag-view)) (let ((p1 (om-view-position self)) (p2 (om-add-points (om-view-position self) (om-view-size self)))) (values (om-point-x p1) (om-point-y p1) (om-point-x p2) (om-point-y p2) ))) ;;;=========================================================== ;;; DOES NOT WORK ON WINDOWS ;;;=========================================================== (defmethod build-d&d-image ((dragged om-drag-view) pane) (multiple-value-bind (x1 y1 x2 y2) (om-drag-area dragged) (let ((pp (gp:create-pixmap-port pane (abs (round (- x2 x1))) (abs (round (- y2 y1))) :background :transparent :clear t))) (unwind-protect (progn (om-with-focused-view pp (om-draw-contents-for-drag dragged)) (values (gp:make-image-from-port pp) (+ (- (om-point-x (om-view-position dragged)) (min x1 x2)) (om-point-x (om-drag-view-cursor-pos dragged))) (+ (- (om-point-y (om-view-position dragged)) (min y1 y2)) (om-point-y (om-drag-view-cursor-pos dragged))) )) (progn (gp:destroy-pixmap-port pp) ))))) ;;;=========================================================== ;;; FOR WINDOWS ONLY ;;; CAPI D&D IMAGE DOES NOT WORK ! ;;;=========================================================== #+mswindows (defclass clone-view (om-item-view) ((view :accessor view :initarg :view :initform nil) (clic-pos :accessor clic-pos :initarg :clic-pos :initform nil) )) #+mswindows (defmethod capi::over-pinboard-object-p ((self clone-view) x y) nil) #+mswindows (defmethod om-draw-contents ((self clone-view)) ;(om-draw-rect 0 0 100 100) (setf *override-clipping-shift* t) (om-draw-contents-for-drag (view self)) (setf *override-clipping-shift* nil)) #+mswindows (defmethod start-windows-d&d (self pane pos) nil) #+mswindows (defmethod start-windows-d&d ((self om-drag-view) (pane om-drop-view) pos) (when (drag-image pane) (om-remove-subviews pane (drag-image pane))) (multiple-value-bind (x1 y1 x2 y2) (om-drag-area self) (let ((topleft (om-make-point (min x1 x2) (min y1 y2)))) (setf (drag-image pane) (om-make-graphic-object 'clone-view :view self :clic-pos (om-add-points pos (om-subtract-points (om-view-position self) topleft)) :position topleft :size (om-make-point (- x2 x1) (- y2 y1)))) (om-add-subviews pane (drag-image pane))))) #+mswindows (defmethod end-windows-d&d ((pane om-drop-view)) nil) #+mswindows (defmethod end-windows-d&d ((pane om-drop-view)) (when (drag-image pane) (om-remove-subviews pane (drag-image pane)))) #+mswindows (defmethod update-windows-d&d ((pane om-drop-view) pos) (when (drag-image pane) ;(om-set-view-cursor self (om-get-cursor (if (om-command-key-p) :wait nil))) (om-set-view-position (drag-image pane) (om-subtract-points pos (clic-pos (drag-image pane)))) )) #| ;;; for click&drag actions #+mswindows (defmethod om-click-motion-handler :after ((self om-drop-view) pos) (when (drag-image self) (om-set-view-position (drag-image self) (om-subtract-points pos (clic-pos (drag-image self)))))) #+mswindows (defmethod om-click-release-handler :after ((self om-drop-view) pos) (unwind-protect (when (drag-image self) (or (om-drag-receive self (view (drag-image self)) pos) (om-beep))) (when (drag-image self) (om-remove-subviews self (drag-image self))) (setf (drag-image self) nil) )) #+mswindows (defmethod om-click-motion-handler :after ((self om-drag-view) pos) (om-click-motion-handler (om-view-container self) (om-convert-coordinates pos self (om-view-container self)))) #+mswindows (defmethod om-click-release-handler :after ((self om-drag-view) pos) (om-click-release-handler (om-view-container self) (om-convert-coordinates (om-subtract-points pos (om-drag-view-cursor-pos self)) self (om-view-container self)))) |# ;;;============================================== ;;; END WINDOWS-SPECIFIC PART ;;;============================================== (defun internal-drag-start (self pos) (and (om-drag-start self pos) #+mswindows (oa::start-windows-d&d self (om-view-container self) pos) (capi:drag-pane-object (om-get-view self) ; (capi::pane-layout (capi::top-level-interface self)) self :plist (list :om-object self) :operations '(:move :copy) :image-function #'(lambda (pane) (build-d&d-image self pane)) ) )) (defvar *drag-start-handler* nil) (defun handle-drag-start (pos) (setf *drag-start-handler* pos)) (defmethod om-view-click-handler :before ((view om-drag-view) pos) (handle-drag-start pos)) (defmethod om-click-motion-handler :after ((self om-drag-view) pos) (let ((min-move 2)) (when (or (null *drag-start-handler*) (>= (abs (- (om-point-x pos) (om-point-x *drag-start-handler*))) min-move) (>= (abs (- (om-point-y pos) (om-point-y *drag-start-handler*))) min-move)) (setf (om-drag-view-cursor-pos self) (om-point-mv pos :y -1)) (internal-drag-start self pos) ))) (defvar *last-pinboard-under-mouse* nil) (defun om-drop-callback (self drop-object stage) (flet ((set-effect-for-operation (drop-object) ;; In a real application, this would be clever about which effects to allow. (dolist (effect '(:move :copy)) (when (capi:drop-object-allows-drop-effect-p drop-object effect) (setf (capi:drop-object-drop-effect drop-object) effect) (return t))))) (case stage (:formats (capi:set-drop-object-supported-formats drop-object '(:string :value :om-object :filename-list))) (:enter (multiple-value-bind (x y) (capi::current-pointer-position :relative-to self :pane-relative-p t) (let ((dropview (or (capi::pinboard-object-at-position self x y) self))) (set-effect-for-operation drop-object) (when (and *last-pinboard-under-mouse* (not (equal dropview *last-pinboard-under-mouse*))) (om-drag-leave-view *last-pinboard-under-mouse*)) (om-drag-enter-view dropview) (setf *last-pinboard-under-mouse* dropview)))) (:leave (multiple-value-bind (x y) (capi::current-pointer-position :relative-to self :pane-relative-p t) (let ((dropview (or (capi::pinboard-object-at-position self x y) self))) (set-effect-for-operation drop-object) (om-drag-leave-view dropview)))) (:drag (multiple-value-bind (x y) (capi::current-pointer-position :relative-to self :pane-relative-p t) (let ((dropview (or (capi::pinboard-object-at-position self x y) self))) (when (and dropview (not (equal dropview *last-pinboard-under-mouse*))) (when *last-pinboard-under-mouse* (om-drag-leave-view *last-pinboard-under-mouse*)) (om-drag-enter-view dropview) (setf *last-pinboard-under-mouse* dropview)) (set-effect-for-operation drop-object) #+mswindows (update-windows-d&d self (multiple-value-bind (x y) (capi::current-pointer-position :relative-to self :pane-relative-p t) (om-make-point x y))) ))) (:drop #+mswindows (oa::end-windows-d&d self) (multiple-value-bind (x y) (capi::current-pointer-position :relative-to self :pane-relative-p t) (let ((dropview (or (capi::pinboard-object-at-position self x y) self))) (setf *last-pinboard-under-mouse* nil) (if (or (and (capi:drop-object-provides-format drop-object :filename-list) (om-import-files-in-app self (capi:drop-object-get-object drop-object self :filename-list) (om-make-point (capi::drop-object-pane-x drop-object) (capi::drop-object-pane-y drop-object)))) (and (capi:drop-object-provides-format drop-object :string) (om-drag-string-in-app self (capi:drop-object-get-object drop-object self :string) (om-make-point (capi::drop-object-pane-x drop-object) (capi::drop-object-pane-y drop-object))))) (set-effect-for-operation drop-object) (let* ((dragged-view (capi:drop-object-get-object drop-object self :om-object))) (when dragged-view (let ((drop-position (om-make-point (- (capi::drop-object-pane-x drop-object) (om-point-x (om-drag-view-cursor-pos dragged-view))) (- (capi::drop-object-pane-y drop-object) 1 ;;; VERY BIZARRE: OTHERWISE THERE IS ALWAYS A SHIFT OF 1 PIXEL.... (om-point-y (om-drag-view-cursor-pos dragged-view)))))) (set-effect-for-operation drop-object) (unless (or (not dragged-view) (om-drag-receive dropview dragged-view drop-position (capi:drop-object-drop-effect drop-object))) (setf (capi:drop-object-drop-effect drop-object) nil)) ))))))) ))) (defmethod om-import-files-in-app ((self t) file-list position) nil) (defmethod om-drag-string-in-app ((self t) str position) nil) (defmethod om-drag-receive ((view t) (dragged-view t) position &optional (effect nil)) (declare (ignore view dragged-view effect))) (defmethod om-drag-enter-view ((self t)) nil) (defmethod om-drag-leave-view ((self t)) nil)

Common Lisp

.lisp

cac-t-u-s/om-sharp

GPL-3.0

9/19/2024, 11:25:22 AM (Europe/Amsterdam)

eba6dbd7db73d0ab98a130b3b0781d70bc5e164b1c192acfd127945b4666f8ab

cursor.lisp

cac-t-u-s_om-sharp/src/api/om-api-LW/cursor.lisp

;========================================================================= ; OM API ; Multiplatform API for OpenMusic ; LispWorks Implementation ;========================================================================= ; ; This program 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. ; ; This program 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 this program. If not, see <http://www.gnu.org/licenses/>. ; ;========================================================================= ; Authors: J. Bresson, C. Agon ;========================================================================= ;==================================================================== ; CURSORS ;==================================================================== (export '(om-make-cursor om-add-cursor om-get-cursor om-set-cursor-location om-view-cursor om-set-view-cursor ) :om-api) (in-package :oa) (defparameter *om-cursor-folder* nil) (defparameter *om-cursor-type* #-win32 "tif" #+win32 "cur") (defparameter *om-cursors* nil) ;;; default cursor location to be set by main application (defun om-set-cursor-location (path) (setf *om-cursor-folder* path)) ;;; registers a new cursor ;;; if cursor is a path or file name the cursor is not created yet (defun om-add-cursor (id cursor &optional (click-pos (om-make-point 0 0))) (let ((p (position id *om-cursors* :key 'car)) (curs (if (or (stringp cursor) (pathnamep cursor)) (list cursor click-pos) cursor))) (if p (setf (cadr (nth p *om-cursors*)) curs) (push (list id curs) *om-cursors*)))) ;;; returns the cursor indexed by "id" (defun om-get-cursor (id) (let ((curs (find id *om-cursors* :key 'car))) (when (and curs (listp (cadr curs))) (setf (cadr curs) (om-make-cursor (car (cadr curs)) (cadr (cadr curs))))) (cadr curs))) ;;; Creates a system cursor from name ;;; if name is a pathname, it must point to a valid cursor file ;;; (type can be omitted and will be replaced by the adequate type) ;;; if name is a string it must the name of a cursor file in *om-cursor-folder* (defun om-make-cursor (name &optional (click-pos (om-make-point 0 0))) (let ((cursorpath (if (pathnamep name) (probe-file (if (pathname-type name) name (om-make-pathname :directory name :name (pathname-name name) :type *om-cursor-type*))) (if (and (stringp name) *om-cursor-folder* (probe-file *om-cursor-folder*)) (om-make-pathname :name name :directory *om-cursor-folder* :type *om-cursor-type*)))) (cursor nil)) (if (and cursorpath (probe-file cursorpath)) (setf cursor (capi::load-cursor (list (list :cocoa cursorpath :x-hot (om-point-x click-pos) :y-hot (om-point-y click-pos)) (list :win32 cursorpath)))) (print (format nil "Cursor file: ~S not found!" name))) cursor) ) #+win32(setf win32::*change-cursor-on-gc* nil) ;;;================ ;;; VIEW CURSORS ;;;================ ;;; SETF (LW style) (defmethod om-set-view-cursor ((self om-graphic-object) cursor) (setf (capi::simple-pane-cursor (om-get-view self)) cursor)) ;;; CALLBACK (MCL style) (defmethod om-view-cursor ((self om-graphic-object)) nil) (defmethod update-view-cursor ((self om-view) pos) (setf (capi::simple-pane-cursor self) (om-view-cursor self))) (defmethod update-view-cursor ((self om-item-view) pos) (when (item-container self) (setf (capi::simple-pane-cursor (item-container self)) (om-view-cursor self))))

Common Lisp

.lisp

cac-t-u-s/om-sharp

GPL-3.0

9/19/2024, 11:25:22 AM (Europe/Amsterdam)

49093f4bd793df727097d1f95c3ac4c383adcb4dbab388af1ff17d61083b1326

icons-picts.lisp

cac-t-u-s_om-sharp/src/api/om-api-LW/icons-picts.lisp

;========================================================================= ; OM API ; Multiplatform API for OpenMusic ; LispWorks Implementation ;========================================================================= ; ; This program 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. ; ; This program 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 this program. If not, see <http://www.gnu.org/licenses/>. ; ;========================================================================= ; Authors: J. Bresson, C. Agon ;========================================================================= ;========================================================================= ; Pictures and Icons for OM graphics ;========================================================================= (in-package :om-api) ;;;========== ;;; export : ;;;========== (export '( om-get-know-pict-types om-register-picture om-load-picture-for-view om-pict-width om-pict-height om-draw-picture om-picture-values om-picture-array om-record-pict ) :om-api) ;;;================ (defun om-get-know-pict-types () (mapcar 'string-downcase (append (gp::list-known-image-formats nil) '(:tif)))) ;;; allows calling image by its name from then on (defun om-register-picture (name path) (gp:register-image-translation name (gp:read-external-image path))) (defun om-load-picture-for-view (id view) (gp::load-image (om-get-view view) id)) ;;; pict is a picture identifier (defmethod om-draw-picture ((pict-id t) &key (x 0) (y 0) w h (src-x 0) (src-y 0) src-w src-h) (when pict-id (handler-bind ((error #'(lambda (e) (print (format nil "!!! ~A: ~A" (string-upcase (type-of e)) e)) (abort)))) (let* ((port *curstream*) (image (ignore-errors (gp::load-image port pict-id)))) (when image (unwind-protect (gp::draw-image port image x y :from-x src-x :from-y src-y :to-width (or w (gp:image-width image)) :to-height (or h (gp:image-height image)) :from-width (or src-w (gp:image-width image)) :from-height (or src-h (gp:image-height image))) (gp::free-image port image) ;;; will be freed when port is destroyed )))))) (defmethod om-draw-picture ((pict-id gp::image) &key (x 0) (y 0) w h (src-x 0) (src-y 0) src-w src-h) (handler-bind ((error #'(lambda (e) (print (format nil "!!! ~A: ~A" (string-upcase (type-of e)) e)) (abort)))) (let* ((port *curstream*)) (gp::draw-image port pict-id x y :from-x src-x :from-y src-y :to-width (or w (gp:image-width pict-id)) :to-height (or h (gp:image-height pict-id)) :from-width (or src-w (gp:image-width pict-id)) :from-height (or src-h (gp:image-height pict-id)) )))) #| ; On Windows, the resulting pict has height divided by 2 (?) (defmacro om-record-pict (w h &body body) (let ((portname (gensym)) (imagename (gensym)) (metafilename (gensym))) `(let* ((,metafilename (capi:with-internal-metafile (,portname :pane nil :bounds (list 0 0 ,w ,h)) (let ((*curstream* ,portname)) ,@body))) (,imagename (capi::draw-metafile-to-image oa::*dummy-view* ,metafilename))) (capi::free-metafile ,metafilename) ,imagename))) |# ; Alternative implementation, inspired by LW's "image-scaling" example (defmacro om-record-pict (w h &body body) `(gp:with-pixmap-graphics-port (pixmap oa::*dummy-view* ,w ,h :clear nil) (let ((*curstream* pixmap)) ,@body) (gp:make-image-from-port pixmap))) (defun om-pict-width (image) (gp::image-width image)) (defun om-pict-height (image) (gp::image-height image)) #| (defmethod om-record-picture-in-pict (pict &optional (pos (om-make-point 0 0)) size) (when pict (let* ((pw (om-pict-width pict)) (ph (om-pict-height pict)) (destw (if size (om-point-x size) pw)) (desth (if size (om-point-y size) ph)) (port (gp::create-pixmap-port *dummy-view* (om-point-x size) (om-point-y size) :background :white :clear t)) (image (gp::load-image port pict))) (gp::draw-image *curstream* image (om-point-x pos) (om-point-y pos) :from-width pw :from-height ph :to-width destw :to-height desth) (gp::free-image port image) ))) (defun om-open-score-page (size font) (let ((port (gp::create-pixmap-port *record-view* (om-point-x size) (om-point-y size) :clear t))) (gp::set-graphics-state port :font (if (gp::font-description-p font) (gp::find-best-font port font) font)) port)) (defun om-close-score-page (port size) (let ((image (gp::make-image-from-port port 0 0 (om-point-x size) (om-point-y size)))) (gp::externalize-image port image))) |# ;;;;!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! ;;; SAVE / LOAD PICTURES ; (internalize-image *graph-pres*)) (defvar *temp-pictwin* nil) (defvar *temp-pictlayout* nil) (defun init-pictwin () (setf *temp-pictlayout* (make-instance 'capi:pinboard-layout) *temp-pictwin* (capi:display (make-instance 'capi:interface :display-state :hidden :layout *temp-pictlayout*)))) (defun ensure-pict-win () (or (and *temp-pictwin* *temp-pictlayout*) (init-pictwin))) (defun clean-pict-win () (when *temp-pictwin* (capi::destroy *temp-pictwin*))) (define-action "When quitting image" "Delete temp pict interface" 'clean-pict-win) (defmethod om-externalize-image ((img gp::image)) (ensure-pict-win) (gp::externalize-image *temp-pictlayout* img)) (defmethod om-externalize-image ((img gp::external-image)) img) (defmethod om-internalize-image ((img gp::image)) img) (defmethod om-internalize-image ((img gp::external-image)) (ensure-pict-win) (gp::load-image *temp-pictlayout* img :force-plain t))

Common Lisp

.lisp

cac-t-u-s/om-sharp

GPL-3.0

9/19/2024, 11:25:22 AM (Europe/Amsterdam)

bd64bbf46df73330e13e5646a32dec26f15ece47fef54e47974f847f9be107e6

processes.lisp

cac-t-u-s_om-sharp/src/api/om-api-LW/processes.lisp

;========================================================================= ; OM API ; Multiplatform API for OpenMusic ; LispWorks Implementation ;========================================================================= ; ; This program 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. ; ; This program 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 this program. If not, see <http://www.gnu.org/licenses/>. ; ;========================================================================= ; Authors: J. Bresson, C. Agon ;========================================================================= ;;=========================================================================== ; PROCESSES MANAGEMENT ;;=========================================================================== (in-package :om-api) (export '( om-run-process om-kill-process om-find-process om-stop-process om-resume-process om-poke-process om-process-name om-process-wait om-process-wake-up-at om-eval-in-context om-use-eval-process om-eval-enqueue om-command-line om-run-application om-run-program om-select-program om-get-internal-time om-with-timeout ) :om-api) ;;;=================================== ;;; MULTI PROCESSING ;;;=================================== (declaim (inline om-get-internal-time)) (defun om-get-internal-time () #+mach (mach::mach-time) #-mach (get-internal-real-time)) (declaim (inline om-time-sleep)) (defun om-time-sleep (delay-ms) #+mach (mach::mach-wait-delay delay-ms) #-mach (sleep (/ delay-ms 1000.0))) (declaim (inline time-sleep-until)) (defun time-sleep-until (absolute-time-ms) #+mach (mach::mach-wait-until absolute-time-ms) #-mach (sleep (max 0 (/ (- absolute-time-ms (get-internal-real-time)) 1000.0)))) (defun om-run-process (name func &key priority args) (apply #'mp:process-run-function (append (list name (list :priority (or priority 10)) func) args))) (declaim (inline om-stop-process)) (defun om-stop-process (process) (if (eq (type-of process) 'mp::process) (mp:process-stop process))) (declaim (inline om-resume-process)) (defun om-resume-process (process) (if (and (eq (type-of process) 'mp::process) (mp:process-stopped-p process)) (mp:process-unstop process))) (declaim (inline om-poke-process)) (defun om-poke-process (process) (if (eq (type-of process) 'mp::process) (mp:process-poke process))) (declaim (inline om-kill-process)) (defun om-kill-process (process) (if (eq (type-of process) 'mp::process) (mp:process-kill process))) (defun om-find-process (id) (mp:find-process-from-name id)) (defun om-process-name (process) (if (eq (type-of process) 'mp::process) (mp:process-name process))) (declaim (inline om-process-wait)) (defun om-process-wait (delay-ms) #+mach (mach::mach-wait-delay delay-ms) #-mach (mp:process-wait-with-timeout "Waiting" (/ delay-ms 1000.0))) (declaim (inline om-process-wake-up-at)) (defun om-process-wake-up-at (absolute-time-ms) #+mach (mach::mach-wait-until absolute-time-ms) #-mach (mp:process-wait-with-timeout "Waiting" (/ (- absolute-time-ms (get-internal-real-time)) 1000.0))) (defun om-with-timeout (timeout timeout-function body-fn) (declare (dynamic-extent body-fn)) (let ((process mp:*current-process*)) (labels ((timeout-throw () (when (find-restart 'abort-execution) (invoke-restart 'abort-execution))) (timeout-action () (mp:process-interrupt process #'timeout-throw))) (declare (dynamic-extent #'timeout-throw #'timeout-action)) (let ((timer (mp:make-named-timer 'timer #'timeout-action))) (catch 'tag (unwind-protect (restart-case (progn (when timeout (mp:schedule-timer-relative timer timeout)) (return-from om-with-timeout (funcall body-fn))) (continue-from-timeout () (throw 'tag (when timeout-function (funcall timeout-function)))) (abort-execution () (throw 'tag (when timeout-function (funcall timeout-function))))) (mp:unschedule-timer timer))))))) ;;;========================== ;;; EVALUATION PROCESS MANAGEMENT ;;;========================== (defun om-eval-in-context (form &optional context) (capi::apply-in-pane-process context 'eval form)) (defparameter *use-eval-process* t) (defun om-use-eval-process (mode) (setq *use-eval-process* mode)) (defun om-eval-enqueue (form &key eval-context-view post-action) (let ((eval-fun #'(lambda () (if eval-context-view (om-eval-in-context form eval-context-view) (eval form)) (when post-action (funcall post-action))) )) (if *use-eval-process* (om-lisp::om-eval-on-process eval-fun) (funcall eval-fun) ))) ;;;=============================== ;;; RUN/MANAGE EXTERNAL PROGRAMS ;;;=============================== (defun om-command-line (str &optional (redirect-output nil)) (if #+macosx (pathnamep redirect-output) #-macosx NIL ;(let ((tempfile "~/om-log.txt")) (sys:run-shell-command str :show-window t :wait t :output redirect-output :error-output redirect-output :if-output-exists :append :if-error-output-exists :append) ;(om-lisp::om-open-text-editor :contents (pathname tempfile))) (progn (if redirect-output (sys:call-system-showing-output str :wait t :output-stream om-lisp::*om-stream*) #-win32(sys:run-shell-command str :wait t) #+win32(sys:call-system str :wait t) )))) ;;; path = exe or .app (defun om-run-program (path &optional afterfun) (let ((pathstr (namestring path))) (when (equal (elt pathstr (- (length pathstr) 1)) #\/) (setf pathstr (subseq pathstr 0 (- (length pathstr) 1))) (let ((appname (pathname-name (pathname (subseq pathstr 0 (- (length pathstr) 1)))))) (setf pathstr (namestring (make-pathname :directory (append (pathname-directory path) (list "Contents" "MacOS")) :name appname))))) (mp:process-run-function (namestring path) nil #'(lambda () ;;; (sys::cd dir) #-win32(system::run-shell-command pathstr :wait t) #+win32(system::call-system (format nil "~s" (namestring pathstr)) :wait t) (when afterfun (funcall afterfun)))) (namestring path))) (defun om-run-application (path) (system::call-system (format nil "open ~s" (namestring path)) :wait nil) (namestring path)) ;;; for a process created with om-run-program or om-run-application (defun om-select-program (id) (system::call-system (concatenate 'string "open " (namestring id))))

Common Lisp

.lisp

cac-t-u-s/om-sharp

GPL-3.0

9/19/2024, 11:25:22 AM (Europe/Amsterdam)

1053a0065be3781ece57a65e8fd13ba747bc6645f8952d496acd8f1bbb803ddc

graphics.lisp

cac-t-u-s_om-sharp/src/api/om-api-LW/graphics.lisp

;========================================================================= ; OM API ; Multiplatform API for OpenMusic ; LispWorks Implementation ;========================================================================= ; ; This program 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. ; ; This program 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 this program. If not, see <http://www.gnu.org/licenses/>. ; ;========================================================================= ; Authors: J. Bresson, C. Agon ;========================================================================= ;;=========================================================================== ; GRAPHIC STRUCTURES (points, colors, fonts) ;;=========================================================================== (in-package :om-api) ;;;========================= ;;; export : ;;;========================= (export '( ompoint om-make-point omp om-point-p om-points-equal-p om-add-points om-subtract-points om-point-x om-point-y om-point-* om-point-mv om-point-set om-point-set-values-from-point om-max-point om-min-point om-borne-point om-round-point om-def-point om-make-color om-gray-color om-make-color-alpha om-color-p om-color-r om-color-g om-color-b om-color-a om-color-null-p om-def-color om-color-equal om-make-font om-font-p om-font-face om-font-size om-font-style om-def-font om-lambda om-font-equal om-list-all-fonts om-string-size om-string-wrap om-correct-point om-correct-font om-correct-color ) :om-api) ;;;========================= ;;; DUMMY VIEW ;;; THIS VIEW IS USED BY SEVERAL CAPI FUNCTIONS TO INITIALIZE GRAPHICS COMPONENTS ;;;========================= (defvar *dummy-view* nil) (defun init-dummy-view () (let* ((pl (make-instance 'capi:pinboard-layout))) (capi:display (make-instance 'capi:interface :display-state :hidden :layout pl)) (setf *dummy-view* pl))) (om-api-add-init-fun 'init-dummy-view) ;;;========================= ;;; COMPATIBILITY ;;;========================= (defun om-correct-color (color) (if (om-color-p color) color (om-def-color :gray))) (defun om-correct-point (point) (cond ((om-point-p point) point) ((null point) point) ((numberp point) (om-make-point (- point (ash (ash point -16) 16)) (ash point -16))) ((consp point) (om-make-point (car point) (cadr point))) (t nil))) (defun om-correct-font (font) (if (om-font-p font) font (om-def-font :normal))) ;;;========================= ;;;POINTS ;;;========================= (defstruct ompoint (x 0) (y 0)) ;;; LW facilities are allowed (e.g. NIL, (:character 4), etc.) (defun om-make-point (x y) (make-ompoint :x x :y y)) (defmacro omp (x y) `(om-make-point ,x ,y)) (defmethod make-load-form ((self ompoint) &optional env) (declare (ignore env)) `(make-ompoint :x ,(ompoint-x self) :y ,(ompoint-y self))) (defmethod om-point-p ((self t)) (ompoint-p self)) ;;; COMPAT (defmethod om-point-h ((point ompoint)) (ompoint-x point)) (defmethod om-point-v ((point ompoint)) (ompoint-y point)) (defmethod om-point-x ((point ompoint)) (ompoint-x point)) (defmethod om-point-y ((point ompoint)) (ompoint-y point)) (defmethod om-add-points (point1 point2) (make-ompoint :x (+ (ompoint-x point1) (ompoint-x point2)) :y (+ (ompoint-y point1) (ompoint-y point2)))) (defmethod om-subtract-points (point1 point2) (make-ompoint :x (- (ompoint-x point1) (ompoint-x point2)) :y (- (ompoint-y point1) (ompoint-y point2)))) (defmethod om-points-equal-p (point1 point2) nil) (defmethod om-points-equal-p ((point1 ompoint) (point2 ompoint)) (and (= (ompoint-x point1) (ompoint-x point2)) (= (ompoint-y point1) (ompoint-y point2)))) (defmethod om-point-* ((point ompoint) fact) (make-ompoint :x (* (ompoint-x point) fact) :y (* (om-point-y point) fact))) (defmethod om-point-mv ((point ompoint) &key x y) (if x (setf (ompoint-x point) (+ (ompoint-x point) x))) (if y (setf (ompoint-y point) (+ (ompoint-y point) y))) point) (defmethod om-point-set ((point ompoint) &key x y) (if x (setf (ompoint-x point) x)) (if y (setf (ompoint-y point) y)) point) (defmethod om-point-set-values-from-point ((point ompoint) (from ompoint)) (setf (ompoint-x point) (ompoint-x from)) (setf (ompoint-y point) (ompoint-y from)) point) (defun max-null (a b) (cond ((and a b) (max a b)) ((null a) b) ((null b) a))) (defun min-null (a b) (cond ((and a b) (min a b)) ((null a) b) ((null b) a))) (defmethod om-max-point ((p1 ompoint) (p2 ompoint)) (make-ompoint :x (max-null (ompoint-x p1) (ompoint-x p2)) :y (max-null (ompoint-y p1) (ompoint-y p2)))) (defmethod om-max-point ((p1 ompoint) (p2 null)) p1) (defmethod om-max-point ((p1 null) (p2 ompoint)) p2) (defmethod om-min-point ((p1 ompoint) (p2 ompoint)) (make-ompoint :x (min-null (ompoint-x p1) (ompoint-x p2)) :y (min-null (ompoint-y p1) (ompoint-y p2)))) (defmethod om-min-point ((p1 ompoint) (p2 null)) p1) (defmethod om-min-point ((p1 null) (p2 ompoint)) p2) (defun om-borne-point (p pmin pmax) (om-min-point (om-max-point p pmin) pmax)) (defun om-round-point (p) (make-ompoint :x (round (ompoint-x p)) :y (round (ompoint-y p)))) (defun om-def-point (p defp) (make-ompoint :x (or (ompoint-x p) (ompoint-x defp)) :y (or (ompoint-y p) (ompoint-y defp)))) ;;;========================= ;;;COLORS ;;;========================= (defstruct omcolor (c (color:make-rgb 0 0 0))) (defun om-make-color (r g b &optional a) (make-omcolor :c (color:make-rgb r g b a))) (defun om-gray-color (val &optional a) (make-omcolor :c (color:make-rgb val val val a))) (defmethod om-make-color-alpha ((color omcolor) alpha) (make-omcolor :c (color::color-with-alpha (omcolor-c color) alpha))) (defmethod make-load-form ((self omcolor) &optional env) (declare (ignore env)) `(make-omcolor :c ,(omcolor-c self))) (defmethod om-color-p ((self t)) nil) (defmethod om-color-p ((self omcolor)) t) (defun om-color-r (color) (color::color-red (omcolor-c color))) (defun om-color-g (color) (color::color-green (omcolor-c color))) (defun om-color-b (color) (color::color-blue (omcolor-c color))) (defun om-color-a (color) (color::color-alpha (omcolor-c color))) (defun om-color-null-p (color) (or (null color) (= (color::color-alpha (omcolor-c color)) 0))) (defun om-color-equal (c1 c2) (and (= (om-color-r c1) (om-color-r c2)) (= (om-color-g c1) (om-color-g c2)) (= (om-color-b c1) (om-color-b c2)) (= (om-color-a c1) (om-color-a c2)))) (defun om-def-color (c) (case c (:light-gray (make-omcolor :c (color:make-rgb 0.9 0.9 0.9))) (:gray (make-omcolor :c (color:make-rgb 0.6 0.6 0.6))) (:dark-gray (make-omcolor :c (color:make-rgb 0.3 0.3 0.3))) (:dark-red (make-omcolor :c (color:make-rgb 0.9 0.3 0.3))) (:dark-blue (make-omcolor :c (color:make-rgb 0.2 0.4 0.5))) ;; (:window (make-omcolor :c (color::get-color-spec #+cocoa :transparent #-cocoa :gray90))) (:window (make-omcolor :c (color::get-color-spec #+cocoa :transparent #-cocoa :background))) (:selection (make-omcolor :c #+win32 (color::make-rgb 0.87058825 0.87058825 0.87058825 1) #-win32 (color::make-rgb 0.5 0.5 0.5 1))) (:selection-inv (make-omcolor :c (color::make-rgb 0.9 0.9 0.9))) (:selection-a (make-omcolor :c (color::make-rgb 0.7 0.7 0.7 0.2))) (:toolbar-color (make-omcolor :c (color:make-rgb 0.85 0.85 0.85))) (:text-selection (let ((selectcolor (om-def-color :selection))) (make-omcolor :c (color:make-rgb (/ (om-color-r selectcolor) 2) (/ (om-color-g selectcolor) 2) (/ (om-color-b selectcolor) 2) 0.7)))) ;;; supported symbols = :black :wite :red ... :transparent (otherwise (make-omcolor :c (color::get-color-spec c))) )) ;;;========================= ;;;FONTS ;;;========================= (defmethod om-font-p ((self t)) (gp::font-description-p self)) ;; &allow-other-keys is for compatibility with OM6 patches (defun om-make-font (face size &key (style nil) &allow-other-keys) (gp::make-font-description ;:name face ; --> name is not portable for find-best-font process :family face :size (round size) :slant (if (member :italic style) :italic :roman) :weight (if (member :bold style) :bold :normal) :charset :ansi )) (defun om-font-face (font) (gp::font-description-attribute-value font :family)) (defun om-font-size (font) (gp::font-description-attribute-value font :size)) (defun om-font-style (font) (cond ((and (equal (gp::font-description-attribute-value font :weight) :bold) (equal (gp::font-description-attribute-value font :slant) :italic)) '(:bold :italic)) ((equal (gp::font-description-attribute-value font :slant) :italic) '(:italic)) ((equal (gp::font-description-attribute-value font :weight) :bold) '(:bold)) (t '(:plain)))) (defun om-font-equal (f1 f2) (and (string-equal (om-font-face f1) (om-font-face f2)) (= (om-font-size f2) (om-font-size f2)) (equal (om-font-style f1) (om-font-style f2)))) (defun om-string-size (str font) (if str (multiple-value-bind (left top right bottom) (gp::get-string-extent *dummy-view* str (gp::find-best-font *dummy-view* font)) (values (round (- right left)) (- bottom top))) (values 0 0))) ; (om-string-size "--" (om-def-font :large)) ; (om-string-wrap "azertyuiop qsdfghjklm wxcvbn" 10 (om-def-font :large)) (defun om-string-wrap (str width font) (declare (special *curstream* *dummy-view*)) (let* ((view (or *curstream* *dummy-view*)) (w (max width (om-string-size "--" font)))) (capi::wrap-text-for-pane view str :visible-width w :font (gp::find-best-font view font) ))) (defparameter *def-font* #+macosx '("Consolas" (8 10 11 12)) ;72 ppi #+mswindows '("Segoe UI" (7 7.5 8 9)) ;96 ppi #+linux '("Liberation Sans" (7 8 9 10)) ;96 ppi ) (defparameter *mono-font* #+macosx '("Courier New" 12) #+mswindows '("Courier New" 8) #+linux '("Courier" 10) ) (defparameter *gui-font* #+macosx '("Lucida Grande" (11 12)) #+mswindows '("Segoe UI" (8 9)) #+linux '("Bistream Vera Sans" (9 10)) ) (defparameter *score-font* '("Times New Roman" 10)) (defparameter *fonts-table* (let ((def-face (car *def-font*)) (sizes (cadr *def-font*))) `((:tiny ,(om-make-font def-face (nth 0 sizes))) (:small ,(om-make-font def-face (nth 1 sizes))) (:small-b ,(om-make-font def-face (nth 1 sizes) :style '(:bold))) (:normal ,(om-make-font def-face (nth 2 sizes))) (:normal-b ,(om-make-font def-face (nth 2 sizes) :style '(:bold))) (:large ,(om-make-font def-face (nth 3 sizes))) (:large-b ,(om-make-font def-face (nth 3 sizes) :style '(:bold))) (:gui ,(om-make-font (car *gui-font*) (nth 0 (cadr *gui-font*)))) (:gui-b ,(om-make-font (car *gui-font*) (nth 0 (cadr *gui-font*)) :style '(:bold))) (:gui-title ,(om-make-font (car *gui-font*) (nth 1 (cadr *gui-font*)) :style '(:bold))) (:score ,(apply #'om-make-font *score-font*)) (:mono ,(apply #'om-make-font *mono-font*))))) (defun om-def-font (font-id &key face size style) (let ((font (cadr (find font-id *fonts-table* :key 'car)))) (when font (when face (setf font (gp::augment-font-description font :family face))) (when size (setf font (gp::augment-font-description font :size size))) (when style (setf font (gp::augment-font-description font :slant (if (member :italic style) :italic :roman) :weight (if (member :bold style) :bold :normal))))) font)) ;;; a special font / char code to write a lambda (defparameter *lambda-font* (om-make-font "Times" 10)) (defun om-lambda (&optional size) (let ((font *lambda-font*)) (when size (setf font (gp::augment-font-description font :size size))) (values (code-char 955) font))) ;;; #+win32 (gp::font-description capi-win32-lib::*win32-default-gui-font*)) (defun om-list-all-fonts () (mapcar #'(lambda (font) (gp::font-description-attribute-value font :family)) (gp:list-all-font-names *dummy-view*)))

Common Lisp

.lisp

cac-t-u-s/om-sharp

GPL-3.0

9/19/2024, 11:25:22 AM (Europe/Amsterdam)

8baa72fe02a1b681ed53da281423296be7b3ad2ab51ae26754e1d6e435125b28

output.lisp

cac-t-u-s_om-sharp/src/api/om-lisp-LW/output.lisp

;========================================================================= ; LW Lisp Tools ; Lisp programming tools for LispWorks delivered applications ;========================================================================= ; ; This program 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. ; ; This program 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 this program. If not, see <http://www.gnu.org/licenses/>. ; ;========================================================================= ; Author: J. Bresson ;========================================================================= (in-package :om-lisp) (export 'om-show-output-lines :om-lisp) (defvar *out-buffer* nil) (defvar *out-window* nil) (defclass output-win (capi::interface) ()) (defun show-output-window (&optional windowtitle) (unless *out-window* (setf *out-window* (make-instance 'output-win :title "" :best-width 500 :best-height 400 :layout (make-instance 'simple-layout :description (list (make-instance 'capi::collector-pane :buffer *out-buffer* :font (gp::make-font-description :family "Verdana" :size 10) :width 300 ))) :destroy-callback #'(lambda (window) (declare (ignore window)) (setf *out-window* nil)) :auto-menus nil :menu-bar-items (list (make-instance 'capi::menu :title "File" :items (list (make-instance 'capi::menu-item :title "Close" :callback-type :interface :callback 'quit-interface :accelerator #\w)))) )) ) (capi::execute-with-interface *out-window* #'(lambda () (display *out-window*) (when windowtitle (setf (capi::interface-title *out-window*) windowtitle)) (capi::find-interface 'output-win))) ) (defun om-show-output-lines (lines &optional windowtitle) (unless *out-buffer* (setf *out-buffer* (om-make-buffer))) (om-buffer-delete *out-buffer*) (if (consp lines) (mapc #'(lambda (line) (om-buffer-insert *out-buffer* (format nil "~A~%" line))) lines) (om-buffer-insert *out-buffer* lines)) (show-output-window windowtitle)) ;; test : ;; (om-show-output-lines '("this is a test" "for the default output-text window"))

Common Lisp

.lisp

cac-t-u-s/om-sharp

GPL-3.0

9/19/2024, 11:25:22 AM (Europe/Amsterdam)

f346d94717bbf8dc4845eaad3d39131d279e526b81d45c144d854b0c5bc70478

editor-find-dialogs.lisp

cac-t-u-s_om-sharp/src/api/om-lisp-LW/editor-find-dialogs.lisp

;;=========================================================================== ; LW Lisp Tools ; Lisp programming tools for LispWorks delivered applications ;;=========================================================================== ; ; This program 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. ; ; This program 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 this program. If not, see <http://www.gnu.org/licenses/>. ; ;========================================================================= ; Authors: Jean Bresson, Sheldon Ball, Nicholas Ellis ;========================================================================= ; ; Find and Replace dialogs from S. Ball's ANVITA EDITOR ; ;=========================================================================== (in-package :om-lisp) (defun print-capitalized (keyword) (substitute #\space #\- (string-capitalize keyword))) (define-interface anvita-dialog () ((ae-interface :initform nil :initarg :ae-interface :reader anvita-dialog-interface))) (define-interface find-dialog (anvita-dialog) ((replace-pane :initform nil)) (:panes (find-pane text-input-choice :visible-min-width '(:character 30) :items (:initarg :find-items)) (direction-pane radio-button-panel :title "Direction" :title-position :frame :items '(:up :down) :print-function 'print-capitalized :selected-item :down) (action-buttons push-button-panel :items (:initarg :find-replace-actions) :print-function 'print-capitalized :default-button :find-next :cancel-button :cancel :selection-callback 'find-replace-callback :callback-type :interface-data :layout-class 'column-layout :layout-args '(:uniform-size-p t))) (:layouts (find-replace-layout grid-layout '("Find what:" find-pane) :columns 2 :y-adjust :center) (option-layout row-layout '(nil direction-pane) :y-adjust :center) (find-replace-option-layout column-layout '(find-replace-layout option-layout)) (main-layout row-layout '(find-replace-option-layout action-buttons) :gap 10 :x-adjust (:initarg ((:find-replace-actions-adjust find-replace-actions-adjust) :center)))) (:default-initargs :layout 'main-layout :auto-menus nil :internal-border 10 :title "Find" :visible-max-width t :visible-max-height t)) (define-interface find-replace-dialog (find-dialog) () (:panes (replace-pane text-input-choice :visible-min-width '(:character 30) :items (:initarg :replace-items))) (:layouts (find-replace-layout grid-layout '("Find what:" find-pane "Replace with:" replace-pane) :columns 2 :y-adjust :center)) (:default-initargs :title "Replace")) (defvar *find-strings* nil) (defvar *replace-strings* nil) (defun find-replace-callback (self data) (with-slots (find-pane replace-pane direction-pane) self (if (eq data :cancel) (destroy self) (let* ((find-text (text-input-pane-text find-pane)) (direction (if (eq (choice-selected-item direction-pane) :up) :backward :forward)) (replace-text (and replace-pane (text-input-pane-text replace-pane)))) (pushnew find-text *find-strings* :test 'string-equal) (when replace-text (pushnew replace-text *replace-strings* :test 'string-equal)) (let ((interface (anvita-dialog-interface self))) (with-slots (ep) interface (call-editor ep (list 'do-editor-find-replace-callback find-text replace-text direction data #'(lambda () (execute-with-interface self #'(lambda () (display-message-for-pane self "No more ~S" find-text)))))))))))) (defun move-point-to-found (found buffer point direction) (let* ((mark (or (editor:buffer-mark buffer t) (progn (editor:set-current-mark point) (editor:buffer-mark buffer))))) (editor:move-point mark point) (editor:character-offset (if (eq direction :backward) mark point) found) (editor::set-highlight-buffer-region t buffer))) (defun do-editor-find-replace-callback (find-text replace-text direction data limit-callback) (block done (let* ((buffer (editor:current-buffer)) (point (editor:buffer-point buffer))) (when (eq data :replace-all) (when-let (start (looking-at-editor-string-p find-text point direction)) (editor:move-point point start)) (editor::query-replace-string :point point :direction direction :target find-text :replacement replace-text :do-all t) (return-from done)) (when (eq data :replace) (when-let (start (looking-at-editor-string-p find-text point direction)) (editor::query-replace-string :point start :direction direction :target find-text :replacement replace-text :count 1 :do-all t))) (loop (when-let (found (find-editor-string find-text point direction)) (move-point-to-found found buffer point direction) (return)) (editor:redisplay) (funcall limit-callback) (return))))) (defun find-editor-string (string point direction &optional limit) (let ((pattern (editor::get-search-pattern string direction nil))) (editor::find-pattern point pattern limit))) (defun looking-at-editor-string-p (string point direction) (let* ((buffer (editor:point-buffer point)) (start (editor:buffer-mark buffer t)) (end point)) (and start (editor:with-point ((seek start :temporary)) (let ((found (find-editor-string string seek direction end))) (and found (if (eq direction :forward) (and (editor:point= seek start) (progn (editor:character-offset seek found) (editor:point= seek end))) (and (editor:point= seek end) (progn (editor:character-offset seek found) (editor:point= seek start))))))) start))) (defun find-dialog-find-next (interface) (find-replace-callback interface :find-next)) ;;;================== ;;; ENTRY POINTS ;;;================== (defun display-anvita-dialog (interface class &rest args) (display (apply 'make-instance class :ae-interface interface args) :owner interface)) (defun find-in-file (interface) (display-anvita-dialog interface 'find-dialog :find-replace-actions '(:find-next :cancel) :find-replace-actions-adjust :center :find-items *find-strings*)) (defun replace-in-file (interface) (display-anvita-dialog interface 'find-replace-dialog :find-replace-actions '(:find-next :replace :replace-all :cancel) :find-replace-actions-adjust :center :find-items *find-strings* :replace-items *replace-strings*))

Common Lisp

.lisp

cac-t-u-s/om-sharp

GPL-3.0

9/19/2024, 11:25:22 AM (Europe/Amsterdam)

c2e32cf5acf32acc145fbdb4aac4f4d40cff733ce03551f5b637f2b07d565d71

find-definition.lisp

cac-t-u-s_om-sharp/src/api/om-lisp-LW/find-definition.lisp

;========================================================================= ; LW Lisp Tools ; Lisp programming tools for LispWorks delivered applications ;========================================================================= ; ; This program 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. ; ; This program 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 this program. If not, see <http://www.gnu.org/licenses/>. ; ;========================================================================= ; Author: J. Bresson ;;======================================================================== ;=========================== ; find and edit source code ;=========================== (in-package :om-lisp) (defun open-definition (def-spec) (let ((file (cadr def-spec))) (if (pathnamep file) (if (probe-file file) (om-open-text-editor-at file (car def-spec)) (progn (beep-pane nil) (print (format nil "File ~A not found." file)))) (progn (beep-pane nil) (print (format nil "Unknown location for symbol definition (~A)." (second (car def-spec)))))) )) (defun show-definitions-dialog (symb deflist) (let* ((w 400) (h 300) (win (make-instance 'capi::interface :title (concatenate 'string "Definitions of " (string-upcase (string symb))) :name (gensym) :width w :height h :window-styles nil :auto-menus nil :menu-bar-items (list (make-instance 'capi::menu :title "File" :items (list (make-instance 'capi::menu-item :title "Close" :callback-type :interface :callback #'(lambda (win) (destroy win)) :accelerator #\w)))) ))) (set-hint-table win (list :external-min-width w :external-max-width w :external-min-height h :external-max-height h)) (setf (pane-layout win) (make-instance 'pinboard-layout :internal-border nil :visible-border nil #+cocoa :background #+cocoa :transparent )) (apply-in-pane-process (pane-layout win) (lambda () (setf (capi:layout-description (pane-layout win)) (list (make-instance 'capi::list-panel :x 10 :y 10 :width 370 :height 260 :interaction :single-selection :retract-callback nil :callback-type '(:collection) :test-function 'string-equal :items (loop for item in deflist collect (format nil "~A" (car item))) :action-callback #'(lambda (list) (open-definition (nth (capi::choice-selection list) deflist))) ))))) (capi::display win))) ;;; SPECIAL FOR OM-LISP FIND-DEFINITION (defvar *recorded-src-root* nil) (defvar *new-src-root* nil) (defun om-set-source-tree-root-folder (path) (setq *new-src-root* path) (unless (member :om-deliver *features*) (setq *recorded-src-root* path))) (defun om-restore-source-path (path) (let ((rec-root-dir (pathname-directory *recorded-src-root*)) (path-dir (pathname-directory (translate-logical-pathname path)))) ; truename ? (if (and (>= (length path-dir) (length rec-root-dir)) (equal rec-root-dir (butlast path-dir (- (length path-dir) (length rec-root-dir))))) ;;; => path is recorded in the original rec-root-dir (merge-pathnames (make-pathname :name (pathname-name path) :type (pathname-type path) :directory (append (pathname-directory *new-src-root*) (nthcdr (length rec-root-dir) path-dir))) *new-src-root*) path))) (defun restore-definitions-pathnames (def-list) (loop for def in def-list collect (list (car def) (if (and (or (stringp (cadr def)) (pathnamep (cadr def)))) (let ((restored (om-restore-source-path (cadr def)))) (if (and (pathnamep restored) (probe-file restored)) (truename restored) (cadr def))) (cadr def))))) (defun om-edit-definition (symb) (if (symbolp symb) (let ((definitions (restore-definitions-pathnames (catch 'dspec-err (handler-bind ((error #'(lambda (err) (print (format nil "Error retrieving symbol definition: ~A" err)) (throw 'dspec-err nil)))) (dspec:find-name-locations dspec:*dspec-classes* symb)))))) (if definitions (if (= (length definitions) 1) (open-definition (car definitions)) (show-definitions-dialog symb definitions)) (progn (beep-pane nil) (print (format nil "No definition found for ~A." symb))))) (progn (beep-pane nil) (print (format nil "Error: ~A is not a valid symbol." symb))))) ; (om-edit-definition 'om::om+) ; (setf dspec::*active-finders* (list :internal dspec::*active-finders*)) ; (dspec:find-name-locations dspec:*dspec-classes* 'om::om+) ; (dspec:find-name-locations dspec:*dspec-classes* 'om::bpf) ; (dspec:name-definition-locations dspec:*dspec-classes* 'om::om+)

Common Lisp

.lisp

cac-t-u-s/om-sharp

GPL-3.0

9/19/2024, 11:25:22 AM (Europe/Amsterdam)

484827d6b5d8f45ff5376a5a4d12c29e74e7ae344d8fe5166507ac5dfb4b8f70

lisp-format.lisp

cac-t-u-s_om-sharp/src/api/om-lisp-LW/lisp-format.lisp

;========================================================================= ; LW Lisp Tools ; Lisp programming tools for LispWorks delivered applications ;========================================================================= ; ; This program 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. ; ; This program 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 this program. If not, see <http://www.gnu.org/licenses/>. ; ;========================================================================= ; Author: J. Bresson ;========================================================================= ;;; LISP FORMATTING (in-package :editor) ;;; Redefine this function from :editor, so indent works ;;; even if the region does not start with a Lisp form ;;; and doesn't stop after double comments (;;) (defun lisp-indent-remaining-forms (cur-start form-end end syntax) (when t ; (eq (next-character cur-start) #\( ) (loop (if (point>= form-end end) (return)) ; (point-skip-x-space cur-start syntax nil) (point-skip-x-space cur-start syntax t t) (move-point form-end cur-start) (if (and (form-offset form-end 1) (point< form-end end)) (progn (indent-form cur-start 0 form-end (blank-before-p cur-start)) ; was (indent-form cur-start 0 form-end t) *** - see above (move-point cur-start form-end)) (progn (when (blank-before-p cur-start) (indent-form cur-start 0 end t t)) (return)))))) (in-package :om-lisp) (defun om-lisp-format-buffer (buffer &key (indent t) (whitespaces t)) (setf (editor:buffer-major-mode buffer) "LISP") (editor:with-point ((start (editor:buffers-start buffer)) (end (editor:buffers-end buffer))) (when whitespaces (let ((line-start 0)) (loop for l = 1 then (+ l 1) while (editor::character-at start line-start) do (let* ((line-end (loop for p = line-start then (+ p 1) for last-char = (editor::character-at start p) while (and last-char (not (equal last-char #\Newline))) finally (return p))) (line (om-buffer-substring buffer line-start line-end)) (reformat nil)) ;; (print (list "LINE:" l line-start line-end line)) (when (find #\Tab line) (print (format nil "--- Repacing some Tabs with Spaces (l. ~A)" l)) (setq reformat t) (setq line (substitute #\Space #\Tab line))) (let ((last-char (or (position-if #'(lambda (c) (not (equal c '#\Space))) line :from-end t) -1))) (when (< last-char (1- (length line))) (print (format nil "--- Removing trailing whitespaces (l. ~A)" l)) (setq reformat t) (setq line (subseq line 0 (1+ last-char))))) #| ;; Too dangerous: should escape strings at least... (let ((first-char (or (position-if #'(lambda (c) (not (equal c #\Space))) line) 0))) (let ((double-space (search " " (print (subseq line first-char))))) (when double-space (print "-- Removing multiple whitespaces (l. ~A)" l) (setq reformat t) (setq line (concatenate 'string (subseq line 0 (+ first-char double-space)) (subseq line (+ first-char double-space 1)))) (loop while double-space do (setf line (concatenate 'string (subseq line 0 (+ first-char double-space)) (subseq line (+ first-char double-space 1))) double-space (search " " (subseq line first-char)))) ))) |# (when reformat ;; Rewrite this line ;; (print (list "===>" line)) (om-buffer-delete buffer line-start line-end) (om-buffer-insert buffer line line-start) ) ;; Go to next line (setq line-start (+ line-start (length line) 1)) )) ;;(print "Check for line end...") (unless (equal (editor::character-at start (- line-start 1)) #\Newline) (print (format nil "--- Add Newline at file ending")) (editor::newline (editor:buffers-end buffer))) )) (when indent ;; Indent the whole buffer (editor::lisp-indent-region-for-commands (editor:buffers-start buffer) (editor:buffers-end buffer))) ) ) (defun om-lisp-format-file (path &key (indent t) (whitespaces t)) (when (probe-file path) (print (format nil "Checking Lisp format: ~s" path)) (let ((file-buffer (editor::find-file-buffer path))) (unwind-protect (progn (om-lisp-format-buffer file-buffer :indent indent :whitespaces whitespaces) (when (editor:buffer-modified file-buffer) (print (format nil "Writing reformatted Lisp file: ~s" path)) (editor:save-file-command nil file-buffer) path)) (unless (equal path *load-pathname*) (editor::kill-buffer-no-confirm file-buffer)) )) ))

Common Lisp

.lisp

cac-t-u-s/om-sharp

GPL-3.0

9/19/2024, 11:25:22 AM (Europe/Amsterdam)

6c58a3bf45ba76c83bb78a8aee0c1036087bb3d5df027137627cb8c290d25717

text-buffer.lisp

cac-t-u-s_om-sharp/src/api/om-lisp-LW/text-buffer.lisp

;========================================================================= ; LW Lisp Tools ; Lisp programming tools for LispWorks delivered applications ;========================================================================= ; ; This program 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. ; ; This program 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 this program. If not, see <http://www.gnu.org/licenses/>. ; ;========================================================================= ; Author: J. Bresson ;========================================================================= ;;; TEXT BUFFER UTILS (in-package :om-lisp) ;;;================= ;;; TEXT BUFFER ;;;================= (defun om-make-buffer () (editor::make-buffer (string (gensym)) :base-name "om-text-buffer-" :temporary t)) ; PLUS UTILISE... ; En declarant les objets : ; (hcl::flag-special-free-action b) ; ... ; on peut leur appliquer une action au moment du GC ; ;(defun kill-buffers (object) ; (when (equal (type-of object) 'ombuffer) ; (print (list "buffer garbage" (buffer object))) ; (editor::delete-buffer (buffer object)) ; )) ; ; (hcl::add-special-free-action 'kill-buffers) (defun om-kill-buffer (buffer) (editor::kill-buffer-no-confirm buffer)) (defun om-copy-buffer (buffer) (let ((newbuffer (om-make-buffer))) (ignore-errors (editor::set-buffer-contents newbuffer (editor::points-to-string (editor::buffers-start buffer) (editor::buffers-end buffer)))) newbuffer )) (defun om-buffer-insert (buffer string &optional (position nil)) (editor::use-buffer buffer (if position (editor::with-point ((p (editor:buffers-start buffer))) (editor::character-offset p position) (editor::insert-string p string)) (editor::insert-string (editor:buffer-point buffer) string)))) (defun om-buffer-insert-newline (buffer &optional (position nil)) (editor::use-buffer buffer (if position (editor::with-point ((p (editor:buffers-start buffer))) (editor::character-offset p position) (editor::newline p)) (editor::newline (editor:buffer-point buffer))))) (defun om-buffer-text (buffer) (editor::use-buffer buffer (editor:points-to-string (editor:buffers-start buffer) (editor:buffers-end buffer)))) (defun om-buffer-substring (buffer from &optional to) (editor::use-buffer buffer (editor::with-point ((p1 (editor:buffers-start buffer)) (p2 (if to (editor:buffers-start buffer) (editor:buffers-end buffer)))) (editor::character-offset p1 from) (when to (editor::character-offset p2 to)) (editor:points-to-string p1 p2)))) (defun om-buffer-char (buffer &optional pos) (editor::use-buffer buffer (editor::with-point ((p (if pos (editor:buffers-start buffer) (editor:buffer-point buffer)))) (editor::character-at p pos)))) (defun om-buffer-size (buffer) (editor::use-buffer buffer (editor::count-characters (editor::buffers-start buffer) (editor::buffers-end buffer)))) (defun om-lines-in-buffer (buffer) (editor::use-buffer buffer (+ 1 (editor::count-lines (editor::buffers-start buffer) (editor::buffers-end buffer))))) (defun om-buffer-lines (buffer) (let ((numlines nil) (listlines nil)) (editor::use-buffer buffer (setq numlines (editor::count-lines (editor::buffers-start buffer) (editor::buffers-end buffer))) (setq listlines (editor::list-lines (editor::buffers-start buffer) numlines)) (butlast listlines (- (length listlines) (1+ numlines))) ))) (defun om-buffer-delete (buffer &optional start end) (handler-bind ((error #'(lambda (c) (print (format nil "Error while cleaning text buffer : ~%~A" c)) (om-kill-buffer buffer) (om-make-buffer) ))) (if start (editor::use-buffer buffer (editor::with-point ((p1 (editor::buffers-start buffer)) (p2 (if end (editor::buffers-start buffer) (editor::buffers-end buffer)))) (editor::character-offset p1 start) (when end (editor::character-offset p2 end)) (editor::delete-between-points p1 p2) )) (editor::clear-buffer buffer)))) (defun om-buffer-set (buffer text) (om-buffer-delete buffer) (om-buffer-insert buffer text)) ;;; position de la fin de la ligne courante (ou au point start) (defun om-buffer-line-end (buffer &optional pos) (editor::use-buffer buffer (editor::with-point ((p (if pos (editor::buffers-start buffer) (editor:buffer-point buffer)))) ;(when pos (editor::character-offset p pos)) (when pos (editor::move-point-to-offset p pos)) (let ((rep (editor::next-newline p))) ;; (print (list "NEXT NEWLINE AT" (editor::find-point-offset buffer p) "-->" rep)) rep )))) ;;; position du debut de la ligne courante (ou au point start) (defun om-buffer-line-start (buffer &optional pos) (editor::use-buffer buffer (editor::with-point ((p (if pos (editor::buffers-start buffer) (editor:buffer-point buffer)))) (when pos (editor::character-offset p pos)) (if (editor::same-line-p p (editor::buffers-start buffer)) 0 (if (equal (editor::character-at p 0) #\Newline) pos (+ 1 (editor::find-point-offset buffer (editor::find-previous-character p #\Newline)))) )))) (defun om-buffer-skip-forward (buffer &optional start end) (editor::use-buffer buffer (editor::with-point ((p (if start (editor::buffers-start buffer) (editor:buffer-point buffer))) (limit (if end (editor::buffers-start buffer) (editor::buffers-end buffer)))) (when start (editor::character-offset p start)) (when end (editor::character-offset limit end)) (loop while (and (editor::blank-line-p p) (editor::point< p limit)) do (editor::move-point-to-offset p (editor::next-newline p))) (editor::find-point-offset buffer p)))) (defun om-get-lisp-expression (buffer) (editor::use-buffer buffer ;; (editor::SKIP-LISP-READER-WHITESPACE (editor:buffers-start textbuffer) textbuffer) (editor::current-form-as-read (editor:buffers-start buffer)) )) ;; pour sauter aussi les comments : SKIP-LISP-READER-WHITESPACE ;; tests ;(setf buf (om-make-buffer)) ;(om-buffer-insert buf "123456789") ;(om-buffer-insert buf " ") ;(om-buffer-insert-newline buf) ;(om-buffer-text buf) ;(om-buffer-char buf 4) ;(om-buffer-delete buf) ;(om-buffer-size buf) ;(om-lines-in-buffer buf) ;(setf b2 (om-copy-buffer buf)) ;(om-buffer-substring buf 6 6) ;(editor::kill-buffer-no-confirm (buffer buf)) ;;(editor::delete-buffer (buffer buf)) ;;; DOC fonctions du package EDITOR ; (editor::buffers-start buf) --> renvoie un point correspondant au debut du buffer ; (editor::current-point buf) --> (verif) renvoir lepoint courant (tous buffers confondus) ; (editor::buffer-point buf) --> renvoie le point courant sur un buffer ; (editor::buffer-end point) -> deplace point a la fin du buffer ; (editor::buffer-start point) -> deplace point au debut du debut... buffer ; (editor::delete-buffer buf &optional force-reset) --> efface un buffer ; (editor::clear-buffer) --> ? ; (editor::delete-between-points start end) --> efface entre les deux points ; (editor::delete-characters point &optional (n 1) --> efface n caracteres apres point ; (editor::count-lines beg end) --> compte le nombre de lignes dans le region ; (editor::line-end point) (editor::line-start point) --> ramene point au debut ou a la fin de la ligne ; (editor::list-lines point num) --> ? ; (editor::newline point &optional cound) --> ? ; (editor::start-line-p point) (editor::end-line-p point) --> T si debut ou fin de ligne ; (editor::move-point-to-offset point offset) --> voir a la place de faire characte-offset, start-point, etc. ;;; ecrit le contenu d'un fichier dans le buffer (defun om-buffer-insert-file (buffer path &optional position) (let ((filebuf (editor::find-file-buffer path))) (if position (editor::use-buffer buffer (editor::with-point ((p (editor:buffers-start buffer))) (editor::character-offset p position) (editor::insert-string p (editor::points-to-string (editor::buffers-start filebuf) (editor::buffers-end filebuf))))) (editor::set-buffer-contents buffer (editor::points-to-string (editor::buffers-start filebuf) (editor::buffers-end filebuf))) ) (editor::kill-buffer-no-confirm filebuf))) ;;; ecrit le contenu du buffer dans un fichier (defun om-buffer-write-file (buffer path &key (if-exists :supersede)) (with-open-file (s path :direction :output :if-exists if-exists) (write-string (editor::points-to-string (editor::buffers-start buffer) (editor::buffers-end buffer)) s)))

Common Lisp

.lisp

cac-t-u-s/om-sharp

GPL-3.0

9/19/2024, 11:25:22 AM (Europe/Amsterdam)

447f484be6bad30fb1a808bd0416268456c7ad978e469f7ccbf185139bd8910f

load-om-lisp.lisp

cac-t-u-s_om-sharp/src/api/om-lisp-LW/load-om-lisp.lisp

;========================================================================= ; LW Lisp Tools ; Lisp programming tools for LispWorks delivered applications ;========================================================================= ; ; This program 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. ; ; This program 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 this program. If not, see <http://www.gnu.org/licenses/>. ; ;========================================================================= ; Author: J. Bresson ; Contributions from Sheldon Ball, Nicholas Ellis ;;=========================================================================== ;;=========================================================================== ;This file loads the LW Lisp tools ;;=========================================================================== (defpackage "OM-LISP" (:use "COMMON-LISP" "CL-USER" "CAPI" "LISPWORKS")) (in-package :om-lisp) (defvar *lw-lisp-tools-directory* nil) (setf *lw-lisp-tools-directory* (pathname-directory (truename *load-pathname*))) (defun compile-if-needed-and-load (file &optional (verbose t)) (let* ((lisp-file (truename (if (pathname-type file) file (concatenate 'string (namestring file) ".lisp")))) (fasl-file (probe-file (make-pathname :directory (pathname-directory lisp-file) :device (pathname-device lisp-file) :name (pathname-name lisp-file) :type (pathname-type (cl-user::compile-file-pathname ""))))) (fasl-outofdate (and fasl-file (or (not (file-write-date lisp-file)) (not (file-write-date fasl-file)) (> (file-write-date lisp-file) (file-write-date fasl-file)))))) (when (and (fboundp 'compile-file) (or (not fasl-file) fasl-outofdate)) (compile-file file :verbose verbose) (setf fasl-outofdate nil)) (if fasl-outofdate (progn (print (format nil "WARNING: File ~A is older than the LISP source file. File ~A will be loaded instead." fasl-file lisp-file)) (load lisp-file :verbose verbose)) (catch 'faslerror (handler-bind ((conditions::fasl-error #'(lambda (c) (when (and (fboundp 'compile-file) fasl-file) (print (format nil "File ~s will be recompiled..." fasl-file)) (compile-file file :verbose verbose) (load file :verbose verbose) (throw 'faslerror t) )))) (load file :verbose verbose) )) ))) (mapc #'(lambda (filename) (compile-if-needed-and-load (make-pathname :directory *lw-lisp-tools-directory* :name filename)) (terpri)) '("eval-process" "text-buffer" "find-definition" "editor-find-dialogs" "output" "text-editor" "listener" "lisp-format"))

Common Lisp

.lisp

cac-t-u-s/om-sharp

GPL-3.0

9/19/2024, 11:25:22 AM (Europe/Amsterdam)

ba80b70fdce0d36214af9c7c36a36dab8a3441ae8e16f26943f5015102082868

listener.lisp

cac-t-u-s_om-sharp/src/api/om-lisp-LW/listener.lisp

;========================================================================= ; LW Lisp Tools ; Lisp programming tools for LispWorks delivered applications ;========================================================================= ; ; This program 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. ; ; This program 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 this program. If not, see <http://www.gnu.org/licenses/>. ; ;========================================================================= ; Author: J. Bresson ; Contributions from N. Ellis ;;======================================================================== ;========================================================================= ; Lisp Linener for delivered LispWorks appliations ;========================================================================= (in-package :om-lisp) ;;;=================== ;;; export : ;;;=================== (export '(om-init-output-stream om-print om-print-format om-print-list) :om-lisp) ;;;============================= ;;; LISTENER ;;;============================= (defvar *om-listener* nil) (defvar *om-stream* nil) (defparameter *om-prompt* "") (defparameter *default-listener-font* #+linux(gp::make-font-description :family "Liberation Mono" :size 11) #+macosx(gp::make-font-description :family "Monaco" :size 11) #+mswindows(gp::make-font-description :family "Courier New" :size 9)) (defun om-init-output-stream () (setq *om-stream* (capi:collector-pane-stream (make-instance 'capi:collector-pane))) (setq hcl::*background-output* *om-stream* ) (redef-print)) (defun redef-print () (let ((lispworks::*HANDLE-WARN-ON-REDEFINITION* nil)) (defun print (something &optional stream) (let ((output-stream (or stream *om-stream*))) (progn (write something :stream output-stream :escape t) (terpri output-stream) ;(write-char #\space output-stream) ;(format *om-stream* "~D ~D~%" *om-prompt* something) ) ;(when om-lisp::*om-listener* (listener-end-of-buffer om-lisp::*om-listener*)) something )) )) ;;;============================= ;;; PRINT REDEFS AND UTILS ;;;============================= (defun om-print (obj &optional prompt) (format *om-stream* "~&~A :: ~A~%" (or prompt "") obj) obj) (defun om-print-format (format-string &optional args prompt) (let ((string (apply 'format (append (list nil (concatenate 'string format-string "~%")) args)))) (format *om-stream* (concatenate 'string (if prompt (concatenate 'string prompt " :: ") "") string)) string)) (defun om-print-list (&rest elements) (om-print elements)) ;;;============================= ;;; PRINT WINDOW ;;;============================= (defclass om-listener (capi::interface) ((ip :accessor ip :initarg :ip) (op :accessor op :initarg :op))) (defclass om-listener-pane () ()) (defclass om-listener-in-pane (om-listener-pane capi::listener-pane) ()) (defclass om-listener-out-pane (om-listener-pane capi::collector-pane) ()) ;;; Embed Listener output panes in other windows: (defun om-make-listener-output-pane (&optional font) (make-instance 'om-listener-out-pane :stream *om-stream* :echo-area t :font (or font *default-listener-font*))) (defun om-clear-listener-output-pane (pane) (editor::clear-buffer (capi::editor-pane-buffer pane))) ;(om-make-listener :input t) ;(setf om-lisp::*om-listener* nil) (defun om-make-listener (&key title x y width height initial-lambda initial-prompt font (input nil) (on-top nil) geometry-change-callback) (or (and om-lisp::*om-listener* (capi::find-interface 'om-listener)) (let ((listener-font (or font *default-listener-font*))) (setf om-lisp::*om-listener* (let* ((in (when input (make-instance 'om-listener-in-pane :echo-area t :font listener-font :stream *om-stream* :create-callback (if initial-lambda (lambda (window) (declare (ignore window)) (capi:execute-with-interface *om-listener* initial-lambda)) (lambda (window) (declare (ignore window)) (capi:execute-with-interface *om-listener* (lambda () (in-package :cl-user)))))))) (out (om-make-listener-output-pane font)) (commands (make-instance 'capi:row-layout :description (list (make-instance 'capi::button :text "x" :callback-type :none :callback #'(lambda () (om-clear-listener-output-pane out)))) :ratios '(nil))) ) (make-instance 'om-listener :layout (make-instance 'capi:column-layout :description (if in (list in :divider out commands) (list out commands)) :ratios (if in '(1 nil 5 nil) '(1 nil)) :adjust :right) :window-styles (append (if on-top (list :always-on-top)) (list :no-character-palette)) ;:toolbox :shadowless :textured-background :ip in :op out :title (or title (concatenate 'string "Listener - " (if in "[system int/out]" "[system out]"))) :best-x (or x 100) :best-y (or y (round (- (capi::screen-height (capi:convert-to-screen)) 250))) :best-width (or width 420) :best-height (or height 200) :destroy-callback (lambda (window) (declare (ignore window)) (setf om-lisp::*om-listener* nil)) :geometry-change-callback geometry-change-callback :auto-menus nil ) )) (when initial-prompt (editor::clear-buffer (capi::editor-pane-buffer (op om-lisp::*om-listener*))) (princ initial-prompt *om-stream*) (terpri *om-stream*)) (setf (capi::simple-pane-font (capi::editor-pane-echo-area (op om-lisp::*om-listener*))) listener-font) (when (ip om-lisp::*om-listener*) (setf (capi::simple-pane-font (capi::editor-pane-echo-area (ip om-lisp::*om-listener*))) listener-font) (setf (capi::editor-pane-text (capi::editor-pane-echo-area (ip om-lisp::*om-listener*))) "")) (capi::execute-with-interface om-lisp::*om-listener* #'(lambda (lw) (let ((def-menu (listener-default-window-menus lw))) (setf (capi::interface-menu-bar-items lw) (if (om-listener-window-menus lw) (append (om-listener-window-menus lw) (list (find "Lisp" def-menu :key 'capi::menu-title :test 'string-equal))) def-menu)))) om-lisp::*om-listener*) (capi::display om-lisp::*om-listener*) ))) ;; to be redefined for custom-listener menus (defmethod om-listener-window-menus ((self om-listener)) nil) ;; used if om-listener-window-menus is not redefined ;; the 'Lisp' part will be kept anyway (defmethod listener-default-window-menus ((self om-listener)) (append (list (make-instance 'capi::menu :title "File" :items (append (list (make-instance 'capi::menu-item :title "Close Listener" :callback-type :interface :callback 'listener-close :accelerator #\w)) (if (handler-case (find-class 'om-lisp::om-text-editor-window) (error () nil)) (list (make-instance 'capi::menu-component :items (list (make-instance 'capi::menu-item :title "New..." :callback-type :interface :callback 'listener-new-text-editor :accelerator #\n :enabled-function 'file-operations-enabled) (make-instance 'capi::menu-item :title "Open..." :callback-type :interface :callback 'listener-open-text-file :accelerator #\o :enabled-function 'file-operations-enabled))))) )) (make-instance 'capi::menu :title "Edit" :items (list (make-instance 'capi::menu-component :items (list (make-instance 'capi::menu-item :title "Cut" :callback-type :interface :callback 'listener-cut :accelerator #\x) (make-instance 'capi::menu-item :title "Copy" :callback-type :interface :callback 'listener-copy :accelerator #\c) (make-instance 'capi::menu-item :title "Paste" :callback-type :interface :callback 'listener-paste :accelerator #\v))) (make-instance 'capi::menu-component :items (list (make-instance 'capi::menu-item :title "Select All" :callback 'listener-select-all :accelerator #\a :callback-type :interface) )) (make-instance 'capi::menu-item :title "Text Font" :callback 'choose-listener-font :accelerator nil :callback-type :interface) )) (make-instance 'capi::menu :title "Lisp" :items (list (make-instance 'capi::menu-component :items (list (make-instance 'capi::menu-item :title "Find Definition" :callback-type :interface :callback 'listener-find-definition :enabled-function 'lisp-operations-enabled :accelerator #\.) ;(make-instance 'capi::menu-item :title "Abort" ; :callback-type :interface ; :callback 'listener-abort ; ;:enabled-function 'lisp-operations-enabled ; :accelerator #\A) (make-instance 'capi::menu-item :title "Last Error Backtrace" :callback-type :interface :callback 'listener-error-backtrace :enabled-function 'backtrace-enabled :accelerator #\B))) (make-instance 'capi::menu-component :items (list (make-instance 'capi::menu-item :title "Load File..." :callback-type :interface :callback 'load-a-lisp-file :accelerator nil :enabled-function 'file-operations-enabled) )) ))) )) (defun listener-close (listenerwin) (capi::quit-interface listenerwin)) (defun listener-open-text-file (window) (declare (ignore window)) (open-text-file)) (defun listener-new-text-editor (window) (declare (ignore window)) (om-open-text-editor :lisp t)) (defun find-capi-pane-with-focus (layout) (capi:map-pane-descendant-children layout #'(lambda (p) (when (capi:pane-has-focus-p p) (return-from find-capi-pane-with-focus p))))) (defmethod om-copy-command ((self om-listener-pane)) (call-editor self (list 'editor::copy-to-cut-buffer-command (editor-pane-buffer self)))) (defun listener-copy (listenerwin) (let ((pane (find-capi-pane-with-focus (pane-layout listenerwin)))) (om-copy-command pane))) (defmethod om-paste-command ((self om-listener-pane)) (call-editor self (list 'editor::insert-cut-buffer-command (editor-pane-buffer self)))) (defun listener-paste (listenerwin) (let ((pane (find-capi-pane-with-focus (pane-layout listenerwin)))) (om-paste-command pane))) (defmethod om-cut-command ((self om-listener-pane)) (let ((buffer (editor-pane-buffer self))) (call-editor self (list 'editor::copy-to-cut-buffer-command buffer)) (call-editor self (list 'editor::kill-region-command buffer)))) (defun listener-cut (listenerwin) (let ((pane (find-capi-pane-with-focus (pane-layout listenerwin)))) (om-cut-command pane))) (defmethod om-select-all-command ((self om-listener-pane)) (let ((buffer (editor-pane-buffer self))) (editor::use-buffer buffer (editor::with-point ((p (editor::buffer-point buffer))) (call-editor self (list 'editor:mark-whole-buffer-command)))))) (defun listener-select-all (listenerwin) (let ((pane (find-capi-pane-with-focus (pane-layout listenerwin)))) (om-select-all-command pane))) (defun listener-end-of-buffer (listenerwin) (let* ((pane (op listenerwin)) (buffer (editor-pane-buffer pane))) (capi::apply-in-pane-process pane #'(lambda (pa bu) (editor::use-buffer bu (editor::with-point ((p (editor::buffer-point bu))) (call-editor pa (list 'editor::end-of-buffer-command bu)) ))) pane buffer))) (defmethod load-a-lisp-file ((self t)) (let ((filename (prompt-for-lisp-file))) (when filename (if (probe-file filename) (progn (setf *last-open-directory* (make-pathname :directory (pathname-directory filename))) (load filename) (print (concatenate 'string "File " (namestring filename) " loaded.")) ) (progn (beep-pane nil) (print (concatenate 'string "File " (namestring filename) " not found.")) )) ))) (defun listener-find-definition (listenerwin) (let* ((pane (find-capi-pane-with-focus (pane-layout listenerwin))) (buffer (editor-pane-buffer pane)) (symbol nil)) (editor::use-buffer buffer (setf symbol (editor::intern-symbol-from-string (editor::read-symbol-from-point :previous t :read-package-name t))) (when symbol (om-lisp::om-edit-definition symbol)) ))) (defun om-prompt-on-echo-area (listener-pane message) (with-slots (editor-window) listener-pane (capi::apply-in-pane-process listener-pane 'editor:process-character (list 'editor:message message) editor-window))) (defun om-listener-echo (str) (when om-lisp::*om-listener* (capi:execute-with-interface om-lisp::*om-listener* #'(lambda () (with-slots (op) om-lisp::*om-listener* (om-prompt-on-echo-area op str) ))))) ;;; not called anymore in OM: abort directly from the patch windows (defun listener-abort (listenerwin) (declare (ignore listenerwin)) (om-kill-eval-process) (om-listener-echo "Aborted Evaluation")) ;;;======================== ;;; FONT MANAGEMENT ;;;======================== ;;; applies to one specific Listener window (defmethod change-listener-font ((self om-listener)) (with-slots (op) self (update-listener-font self (capi::prompt-for-font "" :font (capi::simple-pane-font op))))) (defmethod update-listener-font ((self om-listener) new-font) (with-slots (ip op) self (when ip (setf (capi::simple-pane-font ip) new-font) (when (capi::editor-pane-echo-area ip) (setf (capi::simple-pane-font (capi::editor-pane-echo-area ip)) new-font))) (when op (setf (capi::simple-pane-font op) new-font) (when (capi::editor-pane-echo-area op) (setf (capi::simple-pane-font (capi::editor-pane-echo-area op)) new-font))) )) ;;; API function (called form OM): changes the font for all Listener windows (defun om-set-listener-font (new-font) (setf *default-listener-font* new-font) (mapc #'(lambda (w) (update-listener-font w new-font)) (capi::collect-interfaces 'om-listener))) ;;;=========================== ;;; ERROR REPORTING ;;;=========================== (defparameter *error-backtrace* nil) (defun backtrace-enabled (window) (declare (ignore window)) *error-backtrace*) (defun listener-error-backtrace (window) (declare (ignore window)) (om-show-error-backtrace)) (defun om-show-error-backtrace () (if *error-backtrace* (om-lisp::om-show-output-lines *error-backtrace* "Error Backtrace") (progn (beep-pane) (print "no backtrace recorded") nil))) ;;;=========================== ;;; SHELL ;;;=========================== ;;; A Shell in LW ;;; copied from the LW tutorials (defparameter *om-shell* nil) (defclass om-shell-window (capi:interface) ()) ;(om-make-listener :input t) ;(setf om-lisp::*om-listener* nil) (defun om-open-shell (&key x y w h) (or (and om-lisp::*om-shell* (capi::find-interface 'om-shell-window)) (let ((sp (make-instance 'capi:shell-pane))) (capi::display (setf om-lisp::*om-shell* (make-instance 'om-shell-window :title "SHELL" :best-x x :best-y y :best-width (or w 360) :best-height (or h 200) :window-styles '(:no-character-palette) :destroy-callback (lambda (window) (declare (ignore window)) (setf om-lisp::*om-shell* nil)) :layout (make-instance 'capi:simple-layout :description (list sp))))) ))) ; This function emulates user input on pane : (defun send-keys-to-pane-aux (pane string newline-p) (loop for char across string do (capi:call-editor pane char)) (if newline-p (capi:call-editor pane #\Return))) ; This function trampolines to send-keys-to-pane-aux on the right process: (defun send-keys-to-pane (pane string newline-p) (capi:apply-in-pane-process pane 'send-keys-to-pane-aux pane string newline-p)) ;This call emulates the user typing dir followed by Return : (defun om-send-command-to-shell (cmdline) (when *om-shell* (send-keys-to-pane *om-shell* cmdline t))) ;;; (om-open-shell)

Common Lisp

.lisp

cac-t-u-s/om-sharp

GPL-3.0

9/19/2024, 11:25:22 AM (Europe/Amsterdam)

5ab79bcc5e48f594fe0e28e47b324af7aa8f52d2a99c753ca5bcb43c982a8330

eval-process.lisp

cac-t-u-s_om-sharp/src/api/om-lisp-LW/eval-process.lisp

;========================================================================= ; LW Lisp Tools ; Lisp programming tools for LispWorks delivered applications ;========================================================================= ; ; This program 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. ; ; This program 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 this program. If not, see <http://www.gnu.org/licenses/>. ; ;========================================================================= ; Author: J. Bresson ; Contributions from N. Ellis ;;======================================================================== (in-package :om-lisp) (defvar *om-eval-process* nil) (defun om-work-function () #+cocoa(objc:make-autorelease-pool) (mp:ensure-process-mailbox) ;; This should really have an error handler. (loop (let ((event (mp:process-read-event (mp:process-event-queue (mp:get-current-process)) "waiting for events"))) (cond ((functionp event) (funcall event)) ;((consp event) ; (apply (car event) (cdr event))) (t (eval event) ))))) (defparameter *eval-process-name* "eval-thread") (defun init-om-eval-process () (unless (and *om-eval-process* (mp:process-alive-p *om-eval-process*)) (setq *om-eval-process* (mp:process-run-function *eval-process-name* () 'om-work-function)))) (defun om-eval-on-process (expression) (init-om-eval-process) (mp:ensure-process-mailbox *om-eval-process*) (mp:process-send *om-eval-process* expression ;(if (functionp expression) expression ; #'(lambda () (eval expression))) )) (defun om-kill-eval-process () (when (and *om-eval-process* (mp:process-alive-p *om-eval-process*)) (mp::process-kill *om-eval-process*))) (define-action "When quitting image" "Abort EVAL process" 'om-kill-eval-process)

Common Lisp

.lisp

cac-t-u-s/om-sharp

GPL-3.0

9/19/2024, 11:25:22 AM (Europe/Amsterdam)

2b47660debdcfd53a10e16baced1aa64ecc581eeb5b5cf759fdda3b5fef92af2

load.lisp

cac-t-u-s_om-sharp/src/visual-language/load.lisp

;============================================================================ ; om#: visual programming language for computer-assisted music composition ;============================================================================ ; ; This program is free software. For information on usage ; and redistribution, see the "LICENSE" file in this distribution. ; ; This program 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. ; ;============================================================================ ; File author: J. Bresson ;============================================================================ (in-package :om) (defvar *init-func-list* nil) (defun add-om-init-fun (func-name) (unless (member func-name *init-func-list* :test 'equal) (pushnew func-name *init-func-list*))) (defun om-init-funcall () ;(om-print-dbg "START INIT CALLS") (mapc #'(lambda (x) (om-print-dbg (string x)) (funcall x)) (reverse *init-func-list*)) ;(om-print-dbg "END INIT CALLS") ) (mapc #'(lambda (filename) (cl-user::compile&load (cl-user::decode-local-path filename))) '( "utils/lisptools" "utils/pathnames" "utils/strings" "core/objects" "core/metaclasses" "core/defmethod" "core/defclass" "graphics/graphic-tools" "graphics/icon-picts" "graphics/graphic-components" "graphics/frames" "graphics/rulers" "environment/doc-manager" "environment/session" "environment/properties" "environment/preferences" "environment/package" "environment/library" "environment/function-reference" "environment/swank" "environment/tty-listener" "windows/windows" "windows/main-window" "windows/preferences-window" "windows/editor" "windows/multi-editor" "patch/box" "patch/box-io" "patch/boxcall" "patch/boxsimple" "patch/boxobject" "patch/connection" "patch/patch" "patch/patch-component-boxes" "patch/in-out" "patch/meta-inputs" "patch/patch-editor" "patch/boxframe" "patch/box-abstraction" "patch/boxpatch" "patch/eval" "patch/gen-code" "patch/reactive" "patch/comments" "patch/encapsulation" "patch/interfacebox" "patch/lost-reference" "patch/loop" "patch/lisp-function" "boxes/special-boxes" "boxes/control-boxes" "boxes/system-boxes" "boxes/repeat-n" "boxes/mem-collect" "boxes/global" "boxes/init-do" "boxes/send-receive-route" "tools/data-structures" "tools/file-utils" "tools/write-to-disk" "tools/file-stream" "tools/collections" "tools/networking" "utils/traduction" "utils/documentation" "utils/help" "utils/copy" "utils/save" "utils/undo" "utils/compatibility" "packages" ))

Common Lisp

.lisp

cac-t-u-s/om-sharp

GPL-3.0

9/19/2024, 11:25:22 AM (Europe/Amsterdam)

7e2131b065f78742925a82902912271b9161082f16f0b109d66dcef2f4dffb28

packages.lisp

cac-t-u-s_om-sharp/src/visual-language/packages.lisp

;============================================================================ ; om#: visual programming language for computer-assisted music composition ;============================================================================ ; ; This program is free software. For information on usage ; and redistribution, see the "LICENSE" file in this distribution. ; ; This program 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. ; ;============================================================================ ; File author: J. Bresson ;============================================================================ ;========================================================================= ; kernel class/function package setup ;========================================================================= (in-package :om) (omNG-make-package "Visual Language" :container-pack *om-package-tree* :doc "Building blocks and basic tools for creating visual programs" :subpackages (list (omNG-make-package "Lisp" :doc "Basic functions defined in the Lisp programming language" :functions '(first second third nth rest nthcdr butlast reverse length list remove cons append apply funcall mapcar mapcan)) (omNG-make-package "Control" :doc "Special boxes implementing control operators, argument passing and memory" :functions '(seq hub split default) :special-symbols '(in out if and or repeat-n mem global) ) (omNG-make-package "Loop" :doc "Special boxes for visual loop implementation" :special-symbols '(iterate init-do loop-for loop-while loop-list loop-tail accum collect tcollect) ) (omNG-make-package "Data" :doc "Objects and data management" :functions '(clone test-type save-as-text) :classes '(store collection)) (omNG-make-package "Files" :doc "File I/O management and utilities" :functions '(file-chooser infile outfile tmpfile home-directory folder-contents create-pathname pathname-directory pathname-name pathname-type open-file-stream close-file-stream file-write file-write-line file-read-line) ) (omNG-make-package "Reactive" :doc "Special boxes for reactive patches" :functions '(send receive route) ) (omNG-make-package "Interactive boxes" :doc "Interface boxes and widgets (sliders, buttons, etc.)" :special-symbols '(button slider check-box switch list-selection list-menu) ) (omNG-make-package "Meta" :doc "Visual program manipulation" :functions '(get-boxes get-box-by-name file-path) :special-symbols '(thisbox thispatch) ) ))

Common Lisp

.lisp

cac-t-u-s/om-sharp

GPL-3.0

9/19/2024, 11:25:22 AM (Europe/Amsterdam)

f393c301dcc42d2048d48c83eedb16aca51cb6875f8aeb7aecdfff8072d02118

preferences.lisp

cac-t-u-s_om-sharp/src/visual-language/environment/preferences.lisp

;============================================================================ ; om#: visual programming language for computer-assisted music composition ;============================================================================ ; ; This program is free software. For information on usage ; and redistribution, see the "LICENSE" file in this distribution. ; ; This program 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. ; ;============================================================================ ; File author: J. Bresson ;============================================================================ (in-package :om) (defstruct pref-module (id) (name) (items)) (defstruct pref-item (id) (name)(type) (defval) (doc) (value) (visible) (after-fun)) (defun maybe-eval-pref-item-value (pref-item) (cond ((and (member (pref-item-type pref-item) '(:folder :file)) (pref-item-value pref-item) (symbolp (pref-item-value pref-item))) ;;; non-NIL symbol (funcall (pref-item-value pref-item))) (t (pref-item-value pref-item)))) (defun maybe-apply-pref-item-after-fun (pref-item) (when (pref-item-after-fun pref-item) (funcall (pref-item-after-fun pref-item)))) ;;; a list of pref-module (defvar *user-preferences* nil) ;;;====================================================== ;;; MODULES ARE USED TO SORT PREFERENCE ITEMS (defparameter *pref-order* '(:general :appearance :files :score :conversion :midi :osc :audio :libraries :externals)) (defun sort-pref-items (list) (sort list #'(lambda (elt1 elt2) (let ((p1 (position (pref-module-id elt1) *pref-order*)) (p2 (position (pref-module-id elt2) *pref-order*))) (or (null p2) (and p1 p2 (<= p1 p2))))))) (defun find-pref-module (id &optional preferences-list) (find id (or preferences-list *user-preferences*) :key 'pref-module-id)) ;;; ADD A NEW MODULE WITH NAME (defun add-preference-module (id name) (let ((module (find-pref-module id))) (cond (module (om-beep-msg "Warning: Preference module ~A already exists!" id) (setf (pref-module-name module) name)) ((find name *user-preferences* :key 'pref-module-id :test 'string-equal) (om-beep-msg "Warning: A preference module with the name '~A' already exists!" name) (pushr (make-pref-module :id id :name name) *user-preferences*)) (t (pushr (make-pref-module :id id :name name) *user-preferences*))) (setf *user-preferences* (sort-pref-items *user-preferences*)) )) (defun display-om-preferences (&optional module-name) (let ((prefs-to-display (if module-name (list (find-pref-module module-name)) *user-preferences*))) (om-print "============================") (om-print "CURRENT PREFERENCES:") (om-print "============================") (loop for module in prefs-to-display do (om-print (format nil "MODULE: ~A" (pref-module-name module))) (loop for prefitem in (pref-module-items module) unless (equal (pref-item-type prefitem) :title) do (om-print (format nil " ~A = ~A ~A" (pref-item-id prefitem) (pref-item-value prefitem) (if (pref-item-visible prefitem) "" "[hidden]")))) (om-print "============================")) )) ; (display-om-preferences) ;;;====================================================== ;;; ADD A NEW PREF IN MODULE ;;; we don't want the preference to be visible until this is called (e.g. the lib is loaded.) (defun put-default-value (pref &optional with-after-action) (unless (or (equal (pref-item-type pref) :title) (equal (pref-item-type pref) :action) (equal (pref-item-defval pref) :no-default)) (unless (equal (pref-item-defval pref) (pref-item-value pref)) (setf (pref-item-value pref) (pref-item-defval pref)) (when with-after-action (maybe-apply-pref-item-after-fun pref))) )) (defun add-preference (module-id pref-id name type defval &optional doc after-fun) (unless (find-pref-module module-id) (add-preference-module module-id (string module-id))) (let* ((module (find-pref-module module-id)) (pref-item (find pref-id (pref-module-items module) :key 'pref-item-id))) (if pref-item ;; the pref already exist (e.g. it was already loaded when this function s called): ;; we update its name, defval etc. but keep the value ;(om-print "Warning: A preference with the same ID '~A' already exists!" pref-id) (setf (pref-item-name pref-item) name (pref-item-type pref-item) type (pref-item-defval pref-item) defval (pref-item-doc pref-item) doc (pref-item-after-fun pref-item) after-fun (pref-item-visible pref-item) t) (let ((new-pref (make-pref-item :id pref-id :name name :type type :defval defval :doc doc :after-fun after-fun :visible t))) (put-default-value new-pref) (setf (pref-module-items module) (append (pref-module-items module) (list new-pref)))) ))) ;;; hack ;;; todo: check that this section does not already exist ;;; it is useful to explicitely specify the sub-items of a section in order to ensure the display order ;;; in case things are loaded in a different order. (defun add-preference-section (module-id name &optional doc sub-items) (let* ((module (find-pref-module module-id)) (existing-item (find name (remove-if-not #'(lambda (item) (equal (pref-item-id item) :title)) (pref-module-items module)) :test 'string-equal :key 'pref-item-name))) (if existing-item (setf (pref-item-value existing-item) sub-items) (setf (pref-module-items module) (append (pref-module-items module) (list (make-pref-item :id :title :name name :type :title :visible t :value sub-items :doc doc))))))) ;;; will use the preference section's sub-items to sort (defun order-preference-module (module) (let ((sections (loop for item in (pref-module-items module) when (equal (pref-item-type item) :title) collect item))) ;;; reorder the list (loop for section in sections do (let ((pos (position section (pref-module-items module)))) (loop for sub-item in (pref-item-value section) for i from 1 do (let ((sub (find sub-item (pref-module-items module) :key 'pref-item-id))) (when sub (setf (pref-module-items module) (remove sub (pref-module-items module))) (setf pos (position section (pref-module-items module))) (setf (pref-module-items module) (append (subseq (pref-module-items module) 0 (+ pos i)) (list sub) (subseq (pref-module-items module) (+ pos i)))))))) ) )) ;;;====================================================== ;;; GET THE PREFERENCE VALUES (defun get-pref-in-module (module pref-id) (find pref-id (pref-module-items module) :key 'pref-item-id)) (defun get-pref (module-name pref-key &optional preferences-list) (let ((module (find-pref-module module-name preferences-list))) (when module (get-pref-in-module module pref-key)))) (defun get-pref-value (module-name pref-key &optional preferences-list) (let ((pref-item (get-pref module-name pref-key preferences-list))) (if pref-item (maybe-eval-pref-item-value pref-item) (om-beep-msg "Preference '~A' not found in module '~A'" pref-key module-name)))) (defun restore-default-preferences (&optional pref-module-id) (loop for module in *user-preferences* when (or (not pref-module-id) (equal pref-module-id (pref-module-id module))) do (loop for pref in (pref-module-items module) do (put-default-value pref t)))) ;;;====================================================== ;;; SET THE PREFERENCE VALUES (defmethod set-pref-in-module (module key val) (let ((pref-item (get-pref-in-module module key))) (if pref-item (setf (pref-item-value pref-item) val) ;;; the pref doesn't exist : we just add it silently as 'invisible' (setf (pref-module-items module) (append (pref-module-items module) (list (make-pref-item :id key :name (string key) :type NIL :defval val :value val :visible nil))))) ) ;;; will be called also when loading the preferences (i.e. a lot of times!) (save-preferences) ) (defun set-pref (module-name key val &optional preferences-list) (set-pref-in-module (find-pref-module module-name preferences-list) key val)) ;;;====================================================== ;;; PREFERENCES ARE SAVED AS ;;; (:preferences ;;; (:MODULE-NAME1 (:PREF1 val1) (:PREF-2 VAL2) ...)) ;;; (:MODULE-NAME2 (:PREF1 val1) (:PREF-2 VAL2) ...)) ;;; ... ) ;;;====================================================== ; (save-preferences) (defun save-pref-module (module) (cons (pref-module-id module) (loop for pref in (pref-module-items module) unless (equal :title (pref-item-type pref)) ; (or (equal :action (pref-item-type pref))) collect (list (pref-item-id pref) (omng-save (pref-item-value pref)))))) (defun load-saved-prefs (saved-prefs) (loop for saved-module in saved-prefs do ;;; find the corresponding pref module in preferences (let* ((module-id (car saved-module)) (real-module (find-pref-module module-id))) (when real-module (loop for pref in (cdr saved-module) do (set-pref module-id (car pref) (omng-load (cadr pref))))) ))) ;;;==================================== ;;; SPECIAL TYPES FOR PREFERENCES ;;;==================================== (defstruct number-in-range (min) (max) (decimals)) ;;;==================================== ;;; DEFAULT MODULE ;;;==================================== (add-preference-module :general "General") (add-preference :general :user-name "User name" :string "user") ;;; special case: sets a behavior from the OM-API ;(defmethod set-pref-in-module :after ((module (eql :general)) (key (:eql :listener-on-top)) val) (setf om-lisp::*listener-on-top* val)) ;;; not anymore (initarg in the constructor) (add-preference-section :general "Patch Execution" nil '(:catch-errors :debug :auto-ev-once-mode )) (add-preference-section :general "Lisp REPL" nil '(:listener-on-top :listener-input :listener-font :print-system-output :om-swank-server :listener-in-tty )) (add-preference-section :general "Programming" nil '(:textedit-font :user-code))

Common Lisp

.lisp

cac-t-u-s/om-sharp

GPL-3.0

9/19/2024, 11:25:22 AM (Europe/Amsterdam)

1af41f0fcf1100978a28ea8f09eeaab72fec57f87302547852cfcd87f4b8a69c

package.lisp

cac-t-u-s_om-sharp/src/visual-language/environment/package.lisp

;============================================================================ ; om#: visual programming language for computer-assisted music composition ;============================================================================ ; ; This program is free software. For information on usage ; and redistribution, see the "LICENSE" file in this distribution. ; ; This program 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. ; ;============================================================================ ; File author: J. Bresson ;============================================================================ ;;;=========================== ;;; OMPACKAGE IS A SPECIAL KIND OF FOLDER ;;; WITH ABILITY TO MANAGE CLASS/METHOD DEFINITION AND ORGANIZATION ;;;=========================== (in-package :om) ;;; OMPackage <elements> (inherited from OMFolder) are the subpackages (defclass OMAbstractPackage () ((doc :initform "" :accessor doc :documentation "documentation") (classes :initform nil :accessor classes :documentation "a list of OMClasses") (functions :initform nil :accessor functions :documentation "a list of OMGenericFunctions or standard Lisp functions") (special-items :initform nil :accessor special-items :documentation "a list ofspecial items :)") (aliasclasses :initform nil :accessor aliasclasses :documentation "a list of OMClasses aliases referring classes in other package (used for inheritance)")) (:documentation "This is the class of the OMPackage metaobject. A package is a collection of classes and generic functions. Packages can also contain subpackage and initiate hierearchical package trees. For easier browsing it is recommended that a package do not contain at the same time subpackage and classes or functions. <elements> is a lst of subpackages")) (defclass OMPackage (OMAbstractPackage OMFolder) ()) ;;; used when the package corresponds to a 'real' folder, e.g. for external libraries (defclass OMPersistantPackage (OMAbstractPackage OMPersistantFolder) ()) (defvar *om-package-tree* (make-instance 'OMPackage :name "Root Package") "The package of all predefined functions and classes") (defmethod subpackages ((self OMAbstractPackage)) (elements self)) (defmethod omNG-add-element ((self OMAbstractPackage) (element OMPackage)) (setf (elements self) (append (elements self) (list element)))) (defmethod omNG-add-element ((self OMAbstractPackage) (element OMClass)) (setf (classes self) (append (classes self) (list element)))) (defmethod omNG-add-element ((self OMAbstractPackage) (element standard-class)) (setf (classes self) (append (classes self) (list element)))) (defmethod omNG-add-element ((self OMAbstractPackage) (element function)) (setf (functions self) (append (functions self) (list element)))) (defmethod omNG-add-element ((self OMAbstractPackage) (element symbol)) (setf (special-items self) (append (special-items self) (list element)))) ;;; Empty package (defmethod CleanupPackage ((self OMAbstractPackage)) (setf (elements self) nil (functions self) nil (classes self) nil (aliasclasses self) nil)) ;;; Determines in <container> is a ancestor (container) of <self> (defmethod ancestor-p ((self OMAbstractPackage) (container OMAbstractPackage)) (or (eq self container) (let ((ancestor nil)) (loop for pack in (subpackages self) while (not ancestor) do (setf ancestor (ancestor-p pack container))) ancestor))) ;;; No function in this package and subpackages (defun empty-fun-p (pack) (and (null (functions pack)) (or (null (subpackages pack)) (let ((empty t)) (loop for p in (subpackages pack) while empty do (unless (empty-fun-p p) (setf empty nil))) empty)))) ;;; No class in this package and subpackages (defun empty-class-p (pack) (and (null (classes pack)) (or (null (subpackages pack)) (let ((empty t)) (loop for p in (subpackages pack) while empty do (unless (empty-class-p p) (setf empty nil))) empty)))) ;;; Gets all symbol names in package (defmethod get-name ((self function)) (string-downcase (function-name self))) (defmethod get-name ((self standard-class)) (string-downcase (class-name self))) (defmethod get-name ((self symbol)) (string-downcase (symbol-name self))) ; (get-all-symbol-names *om-package-tree*) (defmethod get-all-symbol-names ((self OMAbstractPackage)) (append (mapcar 'get-name (functions self)) (mapcar 'get-name (classes self)) (special-items self) (loop for item in (elements self) append (get-all-symbol-names item)))) ;;; Fill package tools : Subpackages ;;; merges the packages if already exists (defmethod AddPackage2Pack ((new-package OMAbstractPackage) inPackage) (let ((existing-pack (find (name new-package) (subpackages inPackage) :test 'string-equal :key 'name))) (if existing-pack (progn (setf (functions existing-pack) (append (functions existing-pack) (functions new-package)) (classes existing-pack) (append (classes existing-pack) (classes new-package)) (special-items existing-pack) (append (special-items existing-pack) (special-items new-package)) (elements existing-pack) (append (elements existing-pack) (elements new-package)) ) existing-pack) (progn (omNG-add-element inPackage new-package) new-package)))) (defmethod AddPackage2Pack ((name string) inPackage) (let ((existing-pack (find name (subpackages inPackage) :test 'string-equal :key 'name))) (or existing-pack (AddPackage2Pack (make-instance 'OMPackage :name name) inPackage)))) ;;; Fill package tools : Classes (defmethod AddClass2Pack ((classname symbol) inPackage) (if (find-class classname nil) (unless (find classname (classes inPackage) :test 'equal :key 'class-name) (export-symbol-from-om classname) (omNG-add-element inPackage (find-class classname))) (om-beep-msg (format nil "Undefined class: ~A" classname)))) (defmethod AddClass2Pack ((classname string) inPackage) (AddClass2Pack (read-from-string classname) inPackage)) (defmethod AddClass2Pack ((classname list) inPackage) (mapc #'(lambda (class) (AddClass2Pack class inPackage)) classname)) ;;; Fill package tools : Functions (defmethod AddFun2Pack ((funname symbol) inPackage) (if (fboundp funname) (unless (find funname (functions inPackage) :test 'equal :key 'function-name) (if (subtypep (type-of (fdefinition funname)) 'omgenericfunction) (progn (export-symbol-from-om funname) (omNG-add-element inPackage (fdefinition funname))) (omNG-add-element inPackage (fdefinition funname)))) (om-beep-msg (format nil "Undefined function: ~A" funname)) )) (defmethod AddFun2Pack ((funname string) inPackage) (AddFun2Pack (read-from-string funname) inPackage)) (defmethod AddSpecialItem2Pack ((item symbol) inPackage) (unless (find item (special-items inPackage) :test 'equal) (export-symbol-from-om item) (omNG-add-element inPackage item))) ;;; used to refer in function/class reference pages (defmethod special-item-reference-class ((item t)) nil) (defmethod AddFun2Pack ((funname list) inPackage) (mapcar #'(lambda (fun) (AddFun2Pack fun inPackage)) funname)) ; Creates a package tree form a list of strings (names) and symbols, with pack as root (defun omNG-make-package (package-name &key doc container-pack subpackages functions classes special-symbols) (let* ((new-pack (cond ((and package-name container-pack) (or (find package-name (subpackages container-pack) :key 'name :test 'string-equal) (let ((pack (make-instance 'OMPackage :name package-name))) (addpackage2pack pack container-pack) pack))) (package-name (make-instance 'OMPackage :name package-name)) (container-pack container-pack) (t (make-instance 'OMPackage :name "Untitled Package"))))) (when doc (setf (doc new-pack) doc)) (mapc #'(lambda (class) (addclass2pack class new-pack)) classes) (mapc #'(lambda (fun) (addFun2Pack fun new-pack)) functions) (mapc #'(lambda (sym) (addSpecialItem2pack sym new-pack)) special-symbols) (mapc #'(lambda (pk) (addpackage2pack pk new-pack)) subpackages) new-pack)) (defmethod get-subpackage ((self OMAbstractPackage) subpackage-name) (let ((pack nil)) (loop for p in (elements self) while (not pack) do (if (string-equal (name p) subpackage-name) (setf pack p) (setf pack (get-subpackage p subpackage-name)))) pack)) (defun make-package-menu (pack view position) (om-make-menu (name pack) (remove nil (list (when (functions pack) (om-make-menu-comp (cons (om-make-menu-item "Functions" nil :enabled nil) (loop for f in (functions pack) collect (let ((fun f)) (om-make-menu-item (string (get-name fun)) #'(lambda () (new-box-from-menu (get-name fun) view position)))))))) (when (classes pack) (om-make-menu-comp (cons (om-make-menu-item "Classes/Objects" nil :enabled nil) (loop for c in (classes pack) collect (let ((class c)) (om-make-menu-item (string (get-name class)) #'(lambda () (new-box-from-menu (get-name class) view position)))))))) (when (special-items pack) (om-make-menu-comp (cons (om-make-menu-item "Special boxes" nil :enabled nil) (loop for i in (special-items pack) collect (let ((item i)) (om-make-menu-item (string item) #'(lambda () (new-box-from-menu (get-name item) view position)))))))) (when (elements pack) (om-make-menu-comp (loop for p in (elements pack) collect (make-package-menu p view position)))) )) )) #| ;;; Creates a menu with package functions (defun package-fun2menu (package &optional name action) (let ((subpack (copy-list (subpackages package)))) (om-make-menu (or name "Functions") (list (mapcar #'(lambda (f) (om-make-menu-item (name f) #'(lambda () (funcall action f)))) (functions package)) (remove nil (loop for item in subpack collect (when (and (not (and (subtypep (type-of item) 'OMLib) (not (loaded? item)))) (or (not (empty-fun-p item)) (equal item *package-user*))) (package-fun2menu item (name item) action))) ))))) ;;; Creates a menu with package classes (defun package-classes2menu (package &optional name action) (let ((subpack (copy-list (subpackages package)))) (om-make-menu (or name "Classes") (list (mapcar #'(lambda (c) (om-make-menu-item (name c) #'(lambda () (funcall action c)))) (classes package)) (remove nil (loop for item in subpack collect (when (and (not (and (subtypep (type-of item) 'OMLib) (not (loaded? item)))) (or (not (empty-class-p item)) (equal item *package-user*))) (package-classes2menu item (name item) action))) ))))) |#

Common Lisp

.lisp

cac-t-u-s/om-sharp

GPL-3.0

9/19/2024, 11:25:22 AM (Europe/Amsterdam)

a67d3a38afff6ae53faa01dabff0d792bd7eb7d4684cf050af581fb27f6654fa

swank.lisp

cac-t-u-s_om-sharp/src/visual-language/environment/swank.lisp

;============================================================================ ; om#: visual programming language for computer-aided music composition ; J. Bresson et al., IRCAM (2013-2020) ; Based on OpenMusic (c) IRCAM / G. Assayag, C. Agon, J. Bresson ;============================================================================ ; ; This program is free software. For information on usage ; and redistribution, see the "LICENSE" file in this distribution. ; ; This program 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. ; ;============================================================================ ; File author: A. Vinjar ;============================================================================ ;;; ;;; slime/swank I/O om# <-> emacs ;;; ;;; This file is to enable preference items to control the swank server running ;;; inside om#. Slime/Swank setup is inside src/api/om-slime/om-slime.lisp ;;; ;;; Start swank server to communicate with om# from within Emacs (or other ;;; pipes). Default port - 4005 - is used here: ;;; (in-package :om) (add-preference :general :om-swank-server "Start Swank server" :bool nil "Enable Emacs/Slime communication (in Emacs: 'M-x slime-connect RET RET')" 'update-swank-server) (defvar *swank-server-port* nil) (defun update-swank-server () (if (get-pref-value :general :om-swank-server) (setf *swank-server-port* (swank:create-server)) (swank::stop-server *swank-server-port*) )) (defun init-swank-server () (swank::init) (when (get-pref-value :general :om-swank-server) (setf *swank-server-port* (swank:create-server))) ) (add-om-init-fun 'init-swank-server)

Common Lisp

.lisp

cac-t-u-s/om-sharp

GPL-3.0

9/19/2024, 11:25:22 AM (Europe/Amsterdam)

5a66f1c73b7f0bf4251c7f21314f6a9ee57d4f0b8d6f3f73a23b08b4474658c9

library.lisp

cac-t-u-s_om-sharp/src/visual-language/environment/library.lisp

;============================================================================ ; om#: visual programming language for computer-assisted music composition ;============================================================================ ; ; This program is free software. For information on usage ; and redistribution, see the "LICENSE" file in this distribution. ; ; This program 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. ; ;============================================================================ ; File author: J. Bresson ;============================================================================ ;;;=================================== ;;; EXTERNAL LIBRARIES ;;; ... are just special kinds of dynamic-loaded packages ;;;=================================== (in-package :om) ;;; ideally third-party libraries are coded in a separate Lisp package ;;; these are the basic :OM functions which might be needed in a library (export '(require-library ; requies another lib gen-lib-reference ; auto-generates the lib reference defclass! ; defines a class in the library defmethod! ; defines a method in the library ) :om) (defclass OMLib (OMPersistantPackage) ((version :initform nil :accessor version :initarg :version :documentation "version number (\"a.b.c\")") (author :initform nil :accessor author :initarg :author :documentation "a string documenting authorship/copyright") (source-files :initform nil :accessor source-files :initarg :source-files :documentation "a list of Lisp source files pathnames") (loaded? :initform nil :accessor loaded? :documentation "true if the sources are loaded") )) ;;; conventional folders for library (defmethod lib-resources-folder ((self OMLib)) (merge-pathnames "resources/" (mypathname self))) (defmethod lib-icons-folder ((self OMLib)) (or (probe-file (merge-pathnames "icons/" (lib-resources-folder self))) (merge-pathnames "icon/" (lib-resources-folder self)))) (add-preference-module :libraries "Libraries") (add-preference-section :libraries "Libraries") (add-preference :libraries :libs-folder1 "Search folder 1" :folder :no-default nil 'update-libraries-folder) (add-preference :libraries :libs-folder2 "Search folder 2" :folder :no-default nil 'update-libraries-folder) (add-preference :libraries :libs-folder3 "Search folder 3" :folder :no-default nil 'update-libraries-folder) (add-preference :libraries :libs-folder4 "Search folder 4" :folder :no-default nil 'update-libraries-folder) (add-preference :libraries :auto-load "Auto load" :bool nil "Will silently load any required libraries") ;; typically used from libraries, this Preference tab will deal with external utils' preferences (e.g. Csound, etc.) (add-preference-module :externals "Externals") ;;;================================= ;;; registered libraries package ;;;================================= (defvar *om-libs-root-package* (make-instance 'OMPackage :name "External Libraries Package") "The package containing External libraries") ; (all-om-libraries t) (defun all-om-libraries (&optional loaded-only) (mapcar 'name (if loaded-only (remove-if-not 'loaded? (elements *om-libs-root-package*)) (elements *om-libs-root-package*)))) (defun find-library (name) (find name (elements *om-libs-root-package*) :test 'string-equal :key 'name)) ;;============= (defparameter *libs-folders* nil) (defparameter *default-libs-folder* nil) (defun init-default-libs-folder () (setq *default-libs-folder* (merge-pathnames "libraries/" (om-root-folder)))) (defmethod lib-loader-file ((self OMLib)) (or (probe-file (om-make-pathname :directory (mypathname self) :name (name self) :type "olib")) (probe-file (om-make-pathname :directory (mypathname self) :name (name self) :type "omlib")))) ;;; adds the library to the main package tree ;;; does not load the lib yet (defun register-new-library (name path &optional (warn-if-exists t)) (let ((samelib (find-library name))) (if samelib (when warn-if-exists (om-beep-msg "A library named ~A already exists: ~A. Can not register ~A as new library." name (mypathname samelib) path )) (let ((new-library (make-instance 'OMLib :mypathname path :name name))) (load-library-metadata new-library) (setf (elements *om-libs-root-package*) (append (elements *om-libs-root-package*) (list new-library))) )))) (defun register-all-libraries (&optional (warn-if-exists t)) (unless *default-libs-folder* (init-default-libs-folder)) (loop for folder in (remove nil (list *default-libs-folder* (get-pref-value :libraries :libs-folder1) (get-pref-value :libraries :libs-folder2) (get-pref-value :libraries :libs-folder3) (get-pref-value :libraries :libs-folder4))) do (register-folder-library folder t warn-if-exists))) (defun register-folder-library (folder &optional (recursive t) (warn-if-exists t)) (loop for path in (om-directory folder :directories t :files nil) do (let ((lib-name? (string-until-space (car (last (pathname-directory path)))))) (if (or (probe-file (om-make-pathname :directory path :name lib-name? :type "olib")) (probe-file (om-make-pathname :directory path :name lib-name? :type "omlib"))) ;;; this is a library! (register-new-library lib-name? path warn-if-exists) (if recursive (register-folder-library path t warn-if-exists) (om-beep-msg "Library doesn't have a loader file: ~A.olib not found.." lib-name?)))) )) ;;; called when the folder(s) change ;;; can not unload loaded libraries: won"t be updated (but silently) (defun update-registered-libraries () (declare (special *om-libs-root-package*)) (setf (elements *om-libs-root-package*) (remove-if-not 'loaded? (elements *om-libs-root-package*))) (register-all-libraries nil)) ;; called from the preferences (defun update-libraries-folder () (declare (special *main-window*)) (update-registered-libraries) (when *main-window* (update-libraries-tab *main-window*))) ; (register-all-libraries) ;;;=========== ;;; LOADING ;;;=========== ;;; used by defmethod! and defclass! (defvar *current-lib* nil "containts the library that is being loaded") (defmethod load-library-metadata ((lib OMLib)) (let ((lib-file (lib-loader-file lib))) (when lib-file (let ((lib-data (find-values-in-prop-list (list-from-file lib-file) :om-lib))) (setf (version lib) (find-value-in-kv-list lib-data :version) (doc lib) (find-value-in-kv-list lib-data :doc) (author lib) (find-value-in-kv-list lib-data :author)) )))) ;;; loads a registered library (defmethod load-om-library ((lib string)) (let ((the-lib (find-library lib))) (if the-lib (load-om-library the-lib) (om-beep-msg "Library: ~S not registered !" lib)))) (defmethod load-om-library ((lib OMLib)) (let ((lib-file (lib-loader-file lib))) (if lib-file (handler-bind ((error #'(lambda (c) (progn (om-message-dialog (format nil "Error while loading the library ~A:~%~s" (name lib) (format nil "~A" c))) (abort c))))) (om-print-format "~%~%Loading library: ~A..." (list lib-file)) (let* ((*current-lib* lib) (file-contents (list-from-file lib-file)) (lib-data (find-values-in-prop-list file-contents :om-lib)) (version (find-value-in-kv-list lib-data :version)) (author (find-value-in-kv-list lib-data :author)) (doc (find-value-in-kv-list lib-data :doc)) (files (find-values-in-prop-list lib-data :source-files)) (symbols (find-values-in-prop-list lib-data :symbols))) ;;; update the metadata ? (setf (version lib) version (doc lib) doc (author lib) author) (CleanupPackage lib) ;;; load sources (with-relative-ref-path (mypathname lib) ;;; temp: avoid fasl conflicts for now ;; (cl-user::clean-sources (mypathname lib)) (mapc #'(lambda (f) (let ((path (omng-load f))) ;;; supports both pathnames "om-formatted", and raw pathnames and strings (when (equal (car (pathname-directory path)) :relative) ;;; merge-pathname is not safe here as it sets the pathname-type to :unspecific (breaks load/compile functions) (setf path (om-relative-path (cdr (pathname-directory path)) (pathname-name path) (mypathname lib))) ) (if (string-equal (pathname-name path) "load") ; hack => document that !! (load path) (compile&load path t t (om::om-relative-path '(".om#") nil path))) )) files) ) ;;; set packages (mapc #'(lambda (class) (addclass2pack class lib)) (find-values-in-prop-list symbols :classes)) (mapc #'(lambda (fun) (addFun2Pack fun lib)) (find-values-in-prop-list symbols :functions)) (mapc #'(lambda (item) (addspecialitem2pack item lib)) (find-values-in-prop-list symbols :special-items)) (mapc #'(lambda (pk) (let ((new-pack (omng-load pk))) (addpackage2pack new-pack lib))) (find-values-in-prop-list symbols :packages)) (set-om-pack-symbols) ;; brutal... (register-images (lib-icons-folder lib)) (setf (loaded? lib) t) (update-preference-window-module :libraries) ;;; update if the window is opened (update-preference-window-module :externals) ;;; update if the window is opened (gen-lib-reference lib) (om-print-format "~%==============================================") (om-print-format "~A ~A" (list (name lib) (or (version lib) ""))) (when (doc lib) (om-print-format "~&~A" (list (doc lib)))) (om-print-format "==============================================") lib-file)) (om-beep-msg "Library doesn't have a loader file: ~A NOT FOUND.." (om-make-pathname :directory (mypathname lib) :name (name lib) :type "olib"))) )) ;;; can be called from another library, etc. (defun require-library (name) (om-print-format "Requiring library: ~A" (list name) "OM#") (let ((required-lib (find-library name))) (if required-lib (unless (loaded? required-lib) (load-om-library required-lib)) (om-beep-msg "Required library: ~S not found !" name)) )) ;;;================================= ;;; LOAD LIBRARY-DEPENDENT BOXES ;;;================================= (defmethod get-lib-reference-pages-folder ((self OMLib)) (merge-pathnames (make-pathname :directory '(:relative "reference-pages")) (mypathname self))) (defmethod gen-lib-reference ((lib t)) (om-beep)) (defmethod gen-lib-reference ((lib string)) (gen-lib-reference (find-library lib))) (defmethod gen-lib-reference ((lib OMLib)) (unless (loaded? lib) (load-om-library lib)) ;;; one can define it's own reference-generation function for a lib ;;; by just defining a function called 'gen-LIBNAME-reference' (let ((ref-function (intern-om (string+ "gen-" (name lib) "-reference")))) (if (fboundp ref-function) (funcall ref-function) (gen-reference (gen-package-entries lib) (get-lib-reference-pages-folder lib) :title (name lib) :maintext (doc lib) :logofile (probe-file (merge-pathnames (make-pathname :name "logo" :type "png") (lib-resources-folder lib)))) ))) ; (gen-lib-reference "om-supervp") ;;;================================= ;;; LOAD LIBRARY-DEPENDENT BOXES ;;;================================= (defmethod get-object-library ((self t)) nil) (defmethod get-object-library ((self OMClass)) (find-library (library self))) (defmethod get-object-library ((self OMGenericFunction)) (find-library (library self))) (defmethod get-object-library ((self symbol)) (cond ((fboundp self) (get-object-library (fdefinition self))) ((find-class self nil) (get-object-library (find-class self nil))) (t nil))) (defvar *required-libs-in-current-patch* nil) (defvar *lib-aliases* nil) (defun add-lib-alias (real-name alias-name) (let ((entry (find alias-name *lib-aliases* :key 'car :test 'string-equal))) (if entry (setf (cadr entry) real-name) (push (list alias-name real-name) *lib-aliases*)))) ;;; when the name of a lib changes... :) (defun real-library-name (name) (or (cadr (find name *lib-aliases* :test 'string-equal :key 'car)) name)) (defmethod om-load-from-id :before ((id (eql :box)) data) (let ((library-name (find-value-in-kv-list data :library))) (when library-name ;;; the box comes from a library (let ((real-name (real-library-name library-name))) (when (not (find real-name *required-libs-in-current-patch* :test 'string-equal)) ;;; situation already handled (for this patch): do not repeat (push real-name *required-libs-in-current-patch*) (let ((the-library (find-library real-name))) (if the-library (unless (loaded? the-library) (when (or (get-pref-value :libraries :auto-load) (let ((reply (om-y-n-cancel-dialog (format nil "Some element(s) require the library '~A'.~%~%Do you want to load it ?" real-name) :default :yes))) (if (equal reply :cancel) (abort) reply))) (load-om-library the-library))) (om-message-dialog (format nil "Some element(s) require the unknow library: '~A'.~%~%These boxes will be temporarily disabled." real-name)) ))))))) ;;;================================= ;;; METHOD / CLASS DEFINITION ;;;================================= ; LIBRARY METHOD definition ; Similar to defmethod* + set the flag library of the generic function (defmacro defmethod! (name &rest args) `(let* ((function-already-exists (fboundp ',name)) (themethod (defmethod* ,name ,.args)) (thefunction (fdefinition ',name)) (function-lib (or *current-lib* ;; the lib being loaded (and function-already-exists (library thefunction) (find-library (library thefunction))) ;; the lib specified in the existing function ))) ;;; function is in a user library and did not exist before ;;; we could maybe do this better by tracking in the file system which library we're in (when (and function-lib (not function-already-exists)) (setf (library thefunction) (string-until-space (name *current-lib*)))) ;;; compat with OM6: now we just store the icon id (when (and (find :icon ',args) (listp (icon thefunction))) (setf (icon thefunction) (car (icon thefunction)))) themethod)) ; LIBRARY CLASS definition ; Similar to defclass* + set the flag library of the class (defmacro defclass! (name superclass slots &rest class-options) `(let ((newclass (defclass* ,name ,superclass ,slots ,.class-options))) (when *current-lib* (setf (library (find-class ',name)) (string-until-space (name *current-lib*))) ;;; compat with OM6: now we just store the icon id (if (listp (icon (find-class ',name))) (setf (icon (find-class ',name)) (car (icon (find-class ',name))))) ) newclass))

Common Lisp

.lisp

cac-t-u-s/om-sharp

GPL-3.0

9/19/2024, 11:25:22 AM (Europe/Amsterdam)

2620324b2d22f3fd36a2751dd186ab065613aee018afab437a1206f1660fd7bb

function-reference.lisp

cac-t-u-s_om-sharp/src/visual-language/environment/function-reference.lisp

;============================================================================ ; om#: visual programming language for computer-assisted music composition ;============================================================================ ; ; This program is free software. For information on usage ; and redistribution, see the "LICENSE" file in this distribution. ; ; This program 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. ; ;============================================================================ ; File author: J. Bresson ;============================================================================ ;;;====================================== ;;; GENERATOR OF FUNCTION-REFERENCE PAGES ;;;====================================== (in-package :om) ;;;====================================== ;;; FILE MANAGEMENT / UTILS ;;;====================================== (defun get-reference-pages-folder () (merge-pathnames (make-pathname :directory '(:relative "reference-pages")) (om-resources-folder))) (defun get-reference-pages-index (&optional folder) (merge-pathnames (make-pathname :name "index" :type "html") (or folder (get-reference-pages-folder)))) ;;; characters to avoid in file names (defun special-path-check (name) (let ((pos nil)) (loop while (setf pos (position #\/ name)) do (replace name "I" :start1 pos)) (loop while (setf pos (position #\\ name)) do (replace name "l" :start1 pos)) (loop while (setf pos (position #\: name)) do (replace name "%" :start1 pos)) (loop while (setf pos (position #\* name)) do (replace name "X" :start1 pos)) (loop while (setf pos (position #\? name)) do (replace name "$" :start1 pos)) (loop while (setf pos (position #\" name)) do (replace name "'" :start1 pos)) (loop while (setf pos (position #\> name)) do (replace name ")" :start1 pos)) (loop while (setf pos (position #\< name)) do (replace name "(" :start1 pos)) (loop while (setf pos (position #\| name)) do (replace name "I" :start1 pos)) name)) ;;; characters to avoid in HTML files (defun special-html-check (name) (let ((pos nil)) (loop while (setf pos (position #\> name)) do (setf name (concatenate 'string (subseq name 0 pos) "&gt;" (subseq name (+ pos 1))))) (loop while (setf pos (position #\< name)) do (setf name (concatenate 'string (subseq name 0 pos) "&lt;" (subseq name (+ pos 1))))) name)) ;;;====================================== ;;; AUTO GEN ENTRIES FROM PACKAGES ;;;====================================== ; (gen-package-entries *om-package-tree*) ;;; the toplevel package (defmethod gen-package-entries ((pack OMAbstractPackage) &key exclude-packages) `(:package (:name ,(name pack)) (:doc ,(doc pack)) (:entries ,(remove nil (remove-duplicates (append (mapcar 'class-name (classes pack)) (mapcar 'function-name (functions pack)) (special-items pack)) :test 'string-equal))) (:sections ,(loop for sub-pack in (subpackages pack) when (not (find (name sub-pack) exclude-packages :test 'string-equal)) collect `(:section (:name ,(name sub-pack)) (:doc ,(doc sub-pack)) (:entries ,(remove nil (remove-duplicates (append (mapcar 'class-name (classes sub-pack)) (mapcar 'function-name (functions sub-pack)) (special-items sub-pack)) :test 'string-equal))) (:groups ,(loop for sub-sub-pack in (subpackages sub-pack) when (not (find (name sub-sub-pack) exclude-packages :test 'string-equal)) append (gen-subpack-entries sub-sub-pack :exclude-packages exclude-packages)))) )) )) ;;; will keep all groups at the same hierarchical level (uses append) (defmethod gen-subpack-entries ((pack OMAbstractPackage) &key exclude-packages) (cons `(:group (:name ,(name pack)) (:doc ,(doc pack)) (:entries ,(remove nil (remove-duplicates (append (mapcar 'class-name (classes pack)) (mapcar 'function-name (functions pack)) (special-items pack)) :test 'string-equal)))) (loop for sub-pack in (subpackages pack) when (not (find (name sub-pack) exclude-packages :test 'string-equal)) append (gen-subpack-entries sub-pack :exclude-packages exclude-packages)) )) ;;;====================================== ;;; EXTRACT INFO FROM METAOBJECTS ;;;====================================== (defun fun-to-doclist (symbol) (let ((fun (fdefinition symbol))) (list symbol (if (typep fun 'generic-function) "GENERIC-FUNCTION" "FUNCTION") (function-arglist symbol) (function-documentation symbol)))) (defun class-to-doclist (symbol) (let ((class (find-class symbol nil)) (instance (make-instance symbol))) (list symbol "CLASS" ;;; slots desc (append (loop for slot in (remove-if-not 'slot-initargs (class-direct-instance-slots class)) collect (list (slot-name slot) (eval (slot-initform slot)) (slot-doc slot))) (when (additional-class-attributes instance) (cons "Optional:" (loop for add-slot in (additional-class-attributes instance) collect (let ((slot (find add-slot (class-slots class) :key 'slot-name))) (list add-slot (eval (slot-initform slot)) (slot-doc slot)))))) ) (class-documentation class)))) (defun special-box-to-doclist (symbol) (let* ((ref-class (special-item-reference-class symbol)) (class (find-class ref-class nil))) (when class (let ((instance (make-instance ref-class))) (list symbol "SPECIAL BOX" ;;; slots desc (loop for k in (flat (get-all-keywords instance)) collect (let ((slot (find (symbol-name k) (class-slots class) :key #'(lambda (slot) (symbol-name (slot-name slot))) :test 'string-equal))) (list (slot-name slot) (eval (slot-initform slot)) (slot-doc slot)))) (class-documentation class)))))) ;;;====================================== ;;; REFERENCE-PAGES GENERATION AND ACCESS ;;;====================================== (defun get-documentation-info (symbol) (let ((*print-case* :downcase)) (cond ((fboundp symbol) (fun-to-doclist symbol)) ((find-class symbol nil) (class-to-doclist symbol)) ((special-box-p symbol) (special-box-to-doclist symbol))) )) (defparameter *om-ref-text* "Reference documentation for the main OM# functions and classes.") (defun gen-reference-doc () (gen-reference (gen-package-entries *om-package-tree*) (get-reference-pages-folder) :maintext *om-ref-text*)) (defun ensure-reference-pages () (unless (probe-file (get-reference-pages-index)) (gen-reference-doc))) ;(show-reference-page 'om+) (defmethod show-reference-page ((symbol symbol)) (let* ((lib (get-object-library symbol)) (reference-folder (if lib (let ((folder (get-lib-reference-pages-folder lib))) (unless (probe-file (get-reference-pages-index folder)) (gen-lib-reference lib)) folder) (progn (ensure-reference-pages) (get-reference-pages-folder))))) (let ((file (om-make-pathname :directory reference-folder :name (special-path-check (string-downcase (string symbol))) :type "html"))) (if (probe-file file) (om-open-in-browser (namestring file)) (om-beep-msg "No reference page found for '~A'" symbol)) ))) ;;;====================================== ;;; HTML LAYOUT, CONTENTS AND STYLE ;;;====================================== (defparameter *om-ref-css* "<STYLE TYPE=\"text/css\"><!-- body, p, td, li { background-color: #fff; font-family: \"Calibri\"; font-size: 14; color : #222222; } A:link {text-decoration: underline; color : 333366;} h2 { margin-bottom: 0px; } p { margin-top: 0px; } hr { border: .4px dashed; } table, td { border: 0px; background-color: #f0f0f0; } .frame { width: 80%; max-width: 600px; margin-left: 10%; } .main { border: 1px solid; padding: 20px; background-color: #e5e5e5; } --></style>") (defun credits-line () (concatenate 'string "<br><center><font size=-2>" "Auto doc generation by " *app-name* " " *version-string* " - " (om-get-date nil) "</font></center>")) (defun gen-reference (package-entries dir &key title maintext logofile) (let* ((data (cdr package-entries)) (title (or title (format nil "~A ~A" *app-name* *version-string*))) (indexpath (om-make-pathname :directory dir :name "index" :type "html")) (alphaindexpath (om-make-pathname :directory dir :name "ind-alpha" :type "html")) (allsymbols (remove nil (append (find-value-in-kv-list data :entries) (loop for section in (find-value-in-kv-list data :sections) append (append (find-value-in-kv-list (cdr section) :entries) (loop for group in (find-value-in-kv-list (cdr section) :groups) append (find-value-in-kv-list (cdr group) :entries))))))) (icons-dir (merge-pathnames "icons/" dir)) (logopict (or logofile (om-make-pathname :directory (om-resources-folder) :name "om-sharp" :type "png")))) (when (probe-file dir) (om-delete-directory dir)) (om-create-directory dir) (om-create-directory icons-dir) (when (probe-file logopict) (om-copy-file logopict (om-make-pathname :directory dir :name "logo" :type "png"))) (with-open-file (index indexpath :direction :output) ;;; HEADER (write-line "<html>" index) (write-line (concatenate 'string "<head>") index) (write-line (concatenate 'string "<title>" title " Reference</title>") index) (write-line *om-ref-css* index) (write-line "</head>" index) (write-line "<body>" index) (write-line "<div class=\"frame\">" index) ;;; TITLE BAR (write-line "<div class=\"header\">" index) (when (probe-file logopict) (write-line (concatenate 'string "<img src=logo.png align=\"right\" width=60>") index)) (write-line (concatenate 'string "<H1>" title " reference pages</H1>") index) (write-line "<b>Main Index | <a href=ind-alpha.html>Alphabetical Index</a></b>" index) (write-line "</div>" index) (write-line "<br><hr>" index) ;;; CENTER (when maintext (loop for par in (list! maintext) do (write-line "<p>" index) (write-line par index) (write-line "</p>" index))) ;;; PACKAGE LIST (when (find-value-in-kv-list data :sections) (write-line "<p>Packages covered: " index) (write-line "<ul>" index) (loop for pack in (find-value-in-kv-list data :sections) do (let ((name (find-value-in-kv-list (cdr pack) :name))) (when (and name (not (string-equal name ""))) (write-line (concatenate 'string "<li><b><a href=#" (string name) ">" (string-upcase (string name)) "</a></b></li>") index)))) (write-line "</ul></p>" index)) ;;; MAIN CONTENTS (when (find-value-in-kv-list data :entries) (write-line "<hr>" index) ;;; top level items (not in a section) (loop for item in (find-value-in-kv-list data :entries) do (write-line (concatenate 'string "<a href=" (special-path-check (string-downcase (string item))) ".html>" (special-html-check (string item)) "</a> ") index)) ) (loop for section in (find-value-in-kv-list data :sections) do (let ((name (find-value-in-kv-list (cdr section) :name)) (doc (find-value-in-kv-list (cdr section) :doc))) (write-line "<hr>" index) (when name (write-line (concatenate 'string "<a name=" (string name) ">" "<h2>" (string name) "</h2></a>") index)) (when doc (write-line (concatenate 'string "<p>" doc "</p>") index)) ;;; items in section (not in a sub-group) (write-line "<ul>" index) (loop for item in (find-value-in-kv-list (cdr section) :entries) do (write-line (concatenate 'string "<li><a href=" (special-path-check (string-downcase (string item))) ".html>" (special-html-check (string item)) "</a></li>") index)) (write-line "</ul>" index) (loop for group in (find-value-in-kv-list (cdr section) :groups) do (let ((n (find-value-in-kv-list (cdr group) :name)) (d (find-value-in-kv-list (cdr group) :doc))) (when n (write-line (concatenate 'string "<h3>" (string n) "</h3>") index)) (when d (write-line (concatenate 'string "<p>" (string d) "</p>") index)) (write-line "<ul>" index) (loop for item in (find-value-in-kv-list (cdr group) :entries) do (write-line (concatenate 'string "<li><a href=" (special-path-check (string-downcase (string item))) ".html>" (special-html-check (string item)) "</a></li>") index)) (write-line "</ul>" index) )) )) (write-line "<br><br>" index) (write-line (concatenate 'string "<center>" (credits-line) "</center>") index) (write-line "</div>" index) (write-line "</body></html>" index)) (with-open-file (index alphaindexpath :direction :output) ;;; HEADER (write-line "<html>" index) (write-line (concatenate 'string "<head><title>" title " Reference</title>") index) (write-line *om-ref-css* index) (write-line "</head>" index) (write-line "<body>" index) (write-line "<div class=\"frame\">" index) ;;; TITLE BAR (write-line "<div class=\"header\">" index) (when (probe-file logopict) (write-line (concatenate 'string "<img src=logo.png align=\"right\" width=60>") index)) (write-line (concatenate 'string "<H1>" title " reference pages</H1>") index) (write-line "<b><a href=index.html>Main Index</a> | Alphabetical Index</b>" index) (write-line "</div>" index) (write-line "<br><hr>" index) (mapcar #'(lambda (item) (write-line (concatenate 'string "<a href=" (special-path-check (string-downcase (string item))) ".html>" (string item) "</a><br>") index)) (sort allsymbols 'string<)) (write-line (concatenate 'string "<center>" (credits-line) "</center>") index) (write-line "</div>" index) (write-line "</body></html>" index)) ;;; GENERATE ALL THE PAGES (mapcar #'(lambda (symb) (make-ref-page symb dir title)) allsymbols) indexpath)) (defun make-ref-page (symbol dir &optional title) (let* ((title (or title "")) (pagepath (om-make-pathname :directory dir :name (special-path-check (string-downcase (string symbol))) :type "html")) (doc (get-documentation-info symbol)) (object (cond ((or (string-equal (nth 1 doc) "FUNCTION") (string-equal (nth 1 doc) "GENERIC-FUNCTION")) (fdefinition symbol)) ((string-equal (nth 1 doc) "CLASS") (find-class symbol)) ((string-equal (nth 1 doc) "INTERFACE BOX") (find-class symbol nil))))) (with-open-file (index pagepath :direction :output :if-exists :supersede) ;;; HEADER (write-line "<html>" index) (write-line (concatenate 'string "<head><title>" title " Reference: " (string symbol) "</title>") index) (write-line *om-ref-css* index) (write-line "</head>" index) (write-line "<body>" index) (write-line "<div class=\"frame\">" index) ;;; TITLE BAR (write-line "<div class=\"header\">" index) (write-line (concatenate 'string "<H1>" title " reference pages</H1>") index) (write-line "<b><a href=index.html>Main Index</a> | <a href=ind-alpha.html>Alphabetical Index</a></b>" index) (write-line "<br><br>" index) (write-line "</div>" index) ;;; EMBEDDED TABLE AT CENTER (write-line "<div class=\"main\">" index) ;;; ICON (let ((iconfile (when (and (or (and (string-equal (nth 1 doc) "CLASS") (omclass-p object)) (and (string-equal (nth 1 doc) "GENERIC-FUNCTION") (omgenericfunction-p object))) (icon object)) (if (library object) (om-relative-path '("icons") (format nil "~A.png" (icon object)) (lib-resources-folder (find-library (library object)))) (om-relative-path '("icons" "boxes") (format nil "~A.png" (icon object)) (om-resources-folder))) ))) (when (file-exists-p iconfile) (let ((relative-icon-file (format nil "icons/~A.png" (icon object)))) (om-copy-file iconfile (merge-pathnames relative-icon-file dir)) (write-line (concatenate 'string "<img src=" (namestring relative-icon-file) " align=\"right\" width=60>") index) )) ) ;;; NAME (write-line (concatenate 'string "<h2>" (special-html-check (string symbol)) "</h2>") index) (unless (null doc) (write-line (concatenate 'string "<font size=-1>[" (string (nth 1 doc)) "]" "</font>") index)) ;;; MAIN BODY (if (null doc) (write-line "No documentation" index) (progn (cond ;;; FUNTION ARGUMENTS ((or (string-equal (nth 1 doc) "FUNCTION") (string-equal (nth 1 doc) "GENERIC-FUNCTION")) (write-line "<h3>Function arguments:</h3>" index) (if (null (nth 2 doc)) (write-line "None<br>" index) (progn (write-line "<table width=100%>" index) (loop for arg in (nth 2 doc) for i = 0 then (+ i 1) do (write-line "<tr>" index) (if (and (not (consp arg)) (equal #\& (elt (string arg) 0))) (progn (write-line "<td>" index) (write-line (concatenate 'string "<i><b>" (string-downcase (string arg))"</b></i>") index) (write-line "</td>" index) (write-line "<td colspan=3>&nbsp;</td></tr>" index) (setf i (- i 1))) (let ((argname (if (consp arg) (car arg) arg))) (write-line "<td width=40>&nbsp;</td>" index) (write-line "<td>" index) (write-line (concatenate 'string "- <font color=333366><b>" (string-upcase (format nil "~S" (intern (string-upcase argname)))) "</b></font>") index) (write-line "</td>" index) ;; doc and defaults (if (subtypep (class-of (fdefinition symbol)) 'OMGenericFunction) (let ((indoc (nth i (inputs-doc (fdefinition symbol)))) (defval (nth i (inputs-default (fdefinition symbol))))) (if indoc (write-line (concatenate 'string "<td>" (special-html-check indoc) "</td>") index) (write-line "<td>&nbsp;</td>" index)) (write-line (concatenate 'string "<td>[default = " (format nil "~s" defval) "]</td>") index) ) (progn (write-line "<td width=20%>&nbsp;</td>" index) (if (consp arg) (write-line (concatenate 'string "<td>[default = " (format nil "~s" (cadr arg)) "]</td>") index) (write-line "<td>&nbsp;</td>" index)) ) ) (write-line "</tr>" index) )) (write-line "<tr>" index)) (write-line "</table>" index) ))) ;;; CLASS SLOTS ((or (string-equal (nth 1 doc) "CLASS") (string-equal (nth 1 doc) "INTERFACE BOX")) (write-line "<h3>Class slots/attributes:</h3>" index) (if (null (nth 2 doc)) (write-line "<p>None</p>" index) (progn (write-line "<table width=100% border=0>" index) (loop for slot in (nth 2 doc) do (write-line "<tr>" index) (cond ((not (consp slot)) (write-line "<tr><td colspan=3>&nbsp;</td></tr><td colspan=3>" index) (write-line (concatenate 'string "<i><b>" slot "</b></i>") index) (write-line "</td>" index)) (t (write-line (concatenate 'string "<td > - <font color=333366><b>" (string-upcase (string (car slot))) "</b></font></td>") index) (write-line (concatenate 'string "<td>" (if (nth 2 slot) (special-html-check (nth 2 slot)) "") "</td>") index) (write-line (concatenate 'string "<td>" (format nil "[default = ~A]" (nth 1 slot)) "</td>") index) )) (write-line "</tr>" index) ) (write-line "</table>" index)) )) ))) ;;; DESCRIPTION (when (nth 3 doc) (write-line "<h3>Description:</h3>" index) (loop for str in (om-text-to-lines (nth 3 doc)) do (write-line (concatenate 'string "" (special-html-check str) "<br>") index)) ) (write-line "</div>" index) (write-line (credits-line) index) (write-line "</div>" index) (write-line "</body></html>" index)) pagepath))

Common Lisp

.lisp

cac-t-u-s/om-sharp

GPL-3.0

9/19/2024, 11:25:22 AM (Europe/Amsterdam)

b8519d77c477671c8c5f7b39d8161897f0c84c8954c1f960b6c75d6e141a9ca9

session.lisp

cac-t-u-s_om-sharp/src/visual-language/environment/session.lisp

;============================================================================ ; om#: visual programming language for computer-assisted music composition ;============================================================================ ; ; This program is free software. For information on usage ; and redistribution, see the "LICENSE" file in this distribution. ; ; This program 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. ; ;============================================================================ ; File author: J. Bresson ;============================================================================ ;;;=========================== ;;; SESSION: STARTUP/QUIT ;;;=========================== (in-package :om) ;;;====================================== ;;; GENERAL PREFERENCES ;;;====================================== (defun preference-file () (merge-pathnames "om#/preferences.om#" (om-user-pref-folder))) (defmethod save-preferences () (let ((path (preference-file))) (om-create-directory (make-pathname :directory (pathname-directory path))) (with-open-file (out path :direction :output :external-format :utf-8 :if-does-not-exist :create :if-exists :supersede) (let ((*print-pretty* t)) (pprint `(:info (:saved ,(om-get-date)) (:version ,*version*)) out) (pprint `(:recent-files ,(omng-save (mapcar 'namestring *om-recent-files*))) out) (pprint `(:session-window (:position ,(omng-save *main-window-position*)) (:size ,(omng-save *main-window-size*))) out) (pprint `(:listener-window (:position ,(omng-save *listener-window-position*)) (:size ,(omng-save *listener-window-size*))) out) (pprint `(:user-preferences ,.(mapcar #'save-pref-module *user-preferences*)) out) )) path)) ;(save-preferences) ;(list-from-file (preference-file)) ;(cdr (find :user-preferences pr-list :test 'equal :key 'car) ;;; reads one preference in the preference file (defmethod read-preference (key) (let* ((path (preference-file)) (pref-list (and (file-exists-p path) (list-from-file path)))) (find-values-in-prop-list pref-list key))) ;;; read and load the main prefs for a session (defmethod load-preferences () (let* ((path (preference-file)) (pr-list (and (or (file-exists-p path) (om-beep-msg "Preference file not found: ~A" (namestring path))) (progn (om-print-format "Loading preferences: ~A" (list (namestring path)) "OM") (list-from-file path))))) (setq *om-recent-files* (omng-load (find-value-in-kv-list pr-list :recent-files))) (let ((session-window-geometry (find-values-in-prop-list pr-list :session-window))) (when session-window-geometry (let ((pos (omng-load (find-value-in-kv-list session-window-geometry :position))) (size (omng-load (find-value-in-kv-list session-window-geometry :size)))) (when pos (setq *main-window-position* pos)) (when size (setq *main-window-size* size)) ))) (let ((listener-window-geometry (find-values-in-prop-list pr-list :listener-window))) (when listener-window-geometry (let ((pos (omng-load (find-value-in-kv-list listener-window-geometry :position))) (size (omng-load (find-value-in-kv-list listener-window-geometry :size)))) (when pos (setq *listener-window-position* pos)) (when size (setq *listener-window-size* size)) ))) (load-saved-prefs (find-values-in-prop-list pr-list :user-preferences)) )) ;;;====================================== ;;; THE 'INIT' FOLDER CONTAINS "PATCHES" TO LOAD BEFORE STARTUP ;;;====================================== (defun get-init-patches-folder () (merge-pathnames (make-pathname :directory (cons :relative #-macosx(list "init") #+macosx(if (member :om-deliver *features*) (list (string+ *app-name* ".app") "Contents" "Init") (list "init")) )) (om-root-folder))) (defun load-modif-patches () (let ((patches-folder (get-init-patches-folder))) (om-with-redefinitions (let ((*load-verbose* t)) (when (probe-file patches-folder) (mapc #'(lambda (file) (load file :verbose t)) (sort (om-directory patches-folder :type (list "lisp" (om-compiled-type)) :files t :directories nil) 'string< :key 'pathname-name))) )))) ;;;====================================== ;;; THE 'USER CODE' FOLDER ;;;====================================== (defun load-code-in-folder (folder &optional (recursive t)) (let ((*load-verbose* t)) (mapc #'(lambda (file) (if (and recursive (om-directory-pathname-p file)) (load-code-in-folder file recursive) (load file :verbose t :print t) )) (sort (om-directory folder :type (list "lisp" (om-compiled-type)) :files t :directories t) 'string< :key 'pathname-name)) )) (defun load-user-code () (let ((user-code-folder (get-pref-value :general :user-code))) (when (and user-code-folder (probe-file user-code-folder)) (load-code-in-folder user-code-folder)))) ; (load-user-code) ;;;====================================== ;;; ROOT FOLDER (CALLED IN DELIVER) ;;;====================================== ;;; called in delivered app init (defun init-root-folders () (when (om-standalone-p) (om-set-root-folder (make-pathname :device (pathname-device (oa::om-lisp-image)) :host (pathname-host (oa::om-lisp-image)) :directory #+cocoa(butlast (pathname-directory (truename (lw::pathname-location (oa::om-lisp-image)))) 3) #+win32(pathname-directory (truename (lw::pathname-location (oa::om-lisp-image)))) #+linux (append (butlast (pathname-directory (truename (lw::pathname-location (oa::om-lisp-image))))) '("share" "om-sharp")) )) (om-lisp::om-set-source-tree-root-folder (make-pathname :device (pathname-device (oa::om-lisp-image)) :host (pathname-host (oa::om-lisp-image)) :directory #+cocoa(append (butlast (pathname-directory (truename (lw::pathname-location (oa::om-lisp-image))))) '("Resources" "src")) #+win32(append (pathname-directory (truename (lw::pathname-location (oa::om-lisp-image)))) '("src")) #+linux (append (butlast (pathname-directory (truename (lw::pathname-location (oa::om-lisp-image))))) '("share" "om-sharp" "src")) )) )) ;;;====================================== ;;; MAIN START FUNCTION ;;;====================================== ;;; will be printed in the Listener (defparameter *om-startup-string* (format nil "===========================~%~A v~D~%r. ~A~%===========================" *app-name* *version-string* *release-date*)) ; (start-omsharp) (defvar *om-initialized* nil) (defun start-omsharp () (push :om *features*) (om-lisp::om-init-output-stream) (oa::om-api-init) (om-fi::om-load-foreign-libs #+windows (oa::om-lisp-image) #+macosx (if (oa::om-standalone-p) (om-make-pathname :directory (append (butlast (pathname-directory (oa::om-lisp-image))) '("Frameworks"))) (om-relative-path '("resources" "lib" "mac") nil (oa::om-root-folder))) #+linux (if (oa::om-standalone-p) (om-make-pathname :directory (append (butlast (pathname-directory (oa::om-lisp-image))) '("lib64" "om-sharp"))) (om-relative-path '("resources" "lib" "linux") nil (oa::om-root-folder)))) (load-modif-patches) #+cocoa(objc:make-autorelease-pool) (editor:setup-indent "defmethod*" 2 2 2) (editor:setup-indent "defmethod!" 2 2 2) (editor:setup-indent "defclass*" 2 2 2) (editor:setup-indent "defclass!" 2 2 2) ;(clos::set-clos-initarg-checking nil) (setf *print-case* :downcase) (in-package :om) (set-language *release-language*) (register-om-icons) ;; #+(or om-deliver mswindows) (lispworks::define-action "Confirm when quitting image" "Prompt for confirmation" 'om::quit-om-callback) (load-preferences) (when (find-om-package :midi) (midi-apply-ports-settings)) (om-init-funcall) (register-all-libraries) (save-preferences) (show-main-window :front-tab :listener) (capi:execute-with-interface *main-window* 'eval '(in-package :om)) (om-print-format *om-startup-string*) (load-user-code) (setf *om-initialized* t) ) ;;;====================================== ;;; QUIT ;;;====================================== (defvar *om-exit-actions* nil) (defun add-om-exit-action (action) (pushnew action *om-exit-actions*)) (defun perform-om-exit-actions () (loop for action in *om-exit-actions* do (funcall action))) (defun quit-om-callback () (let ((rep (and (check-om-docs-before-close) (om-lisp::check-buffers-before-close) ;; handled by om-text-edit-window destroy callback ))) (when rep (perform-om-exit-actions)) rep)) ;;;====================================== ;;; EXIT ACTION: SAVE THE PREFERENCES ;;;====================================== (add-om-exit-action 'save-preferences)

Common Lisp

.lisp

cac-t-u-s/om-sharp

GPL-3.0

9/19/2024, 11:25:22 AM (Europe/Amsterdam)

64a26759c31e4d6e0fce182ad560b8a921a8ff42006b56e69e6e357565c7bbcf

tty-listener.lisp

cac-t-u-s_om-sharp/src/visual-language/environment/tty-listener.lisp

;============================================================================ ; om#: visual programming language for computer-aided music composition ; J. Bresson et al., IRCAM (2013-2020) ; Based on OpenMusic (c) IRCAM / G. Assayag, C. Agon, J. Bresson ;============================================================================ ; ; This program is free software. For information on usage ; and redistribution, see the "LICENSE" file in this distribution. ; ; This program 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. ; ;============================================================================ ; File author: A. Vinjar ;============================================================================ (in-package :om) ;; Communication with OM through *terminal-io* ;; ;; listener I/O in tty ;; (add-preference :general :listener-in-tty "Start TTY listener" :bool nil "Start (Stop) a listener in the startup shell" 'start-stop-tty-listener) (defvar *tty-listener-running* nil) (defun start-stop-tty-listener (&optional force) (if (or force (get-pref-value :general :listener-in-tty)) (progn (and (not *tty-listener-running*) (format *terminal-io* "~&Starting TTY Listener")) (lispworks:start-tty-listener) (setf *tty-listener-running* t)) (progn (and *tty-listener-running* (format *terminal-io* "~&Quitting TTY Listener")) (mp:process-terminate (mp:get-process "TTY Listener")) (setf *tty-listener-running* nil)))) (add-om-init-fun 'start-stop-tty-listener)

Common Lisp

.lisp

cac-t-u-s/om-sharp

GPL-3.0

9/19/2024, 11:25:22 AM (Europe/Amsterdam)

f562439e5114a3f9006bda9596edea93c8bc47fd8a603f56bd6f30d4b74e2f11

box.lisp

cac-t-u-s_om-sharp/src/visual-language/patch/box.lisp

;============================================================================ ; om#: visual programming language for computer-assisted music composition ;============================================================================ ; ; This program is free software. For information on usage ; and redistribution, see the "LICENSE" file in this distribution. ; ; This program 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. ; ;============================================================================ ; File author: J. Bresson ;============================================================================ (in-package :om) ;=========================== ;BOXES ;=========================== ;; name is redefined with :initarg (defclass OMBox (OMVPObject) ((container :initform nil :accessor container) (inputs :initform nil :accessor inputs) (outputs :initform nil :accessor outputs) (reference :initform nil :initarg :reference :accessor reference) (group-id :initform nil :accessor group-id :initarg :group-id) ;; id used for grouping boxes (e.g. tracks in a sequencer) (value :initform nil :accessor value) ;; value = a list of one or more value(s) ;;; graphical attributes (frame :initform nil :accessor frame :documentation "the OMFrame representing to the box") (box-x :initform nil :accessor box-x :initarg :box-x) (box-y :initform nil :accessor box-y :initarg :box-y) (box-w :initform nil :accessor box-w :initarg :box-w) (box-h :initform nil :accessor box-h :initarg :box-h) (display :initform :hidden :accessor display :initarg :display) (selected :initform nil :accessor selected :initarg :selected) (border :initform nil :accessor border :initarg :border) (roundness :initform nil :accessor roundness :initarg :border) (color :initform nil :accessor color :initarg :color) (text-font :initform nil :accessor text-font :initarg :text-font) (text-color :initform nil :accessor text-color :initarg :text-color) (text-align :initform nil :accessor text-align :initarg :text-align) (icon-pos :initform :left :accessor icon-pos :initarg :icon-pos) (show-name :initform t :accessor show-name :initarg :show-name) (show-markers :initform t :accessor show-markers :initarg :show-markers) (cache-display :initform nil :accessor cache-display) ;;; REACTIVE FLAGS (gen-lock :accessor gen-lock :initform nil) ;; this box is the event source and his evaluation is locked (gen-flag :accessor gen-flag :initform nil) ;; this box has already been valuated during this generation (push-tag :accessor push-tag :initform nil) ;; this box is tagged as being is in the notification path for the current event (reactive :accessor reactive :initform nil :initarg :reactive)) (:documentation "OMBox is is the more general class for connectable objects (boxes).") (:metaclass omstandardclass)) (add-preference-module :appearance "Appearance") (add-preference-section :appearance "Boxes" "Default values for boxes with unspecified or disabled attributes") (add-preference :appearance :box-color "Color" :color-a (om-make-color .9 .9 .9)) (add-preference :appearance :box-border "Border" (make-number-in-range :min 0 :max 4 :decimals 1) 1.5) (add-preference :appearance :box-roundness "Corner roundness" (make-number-in-range :min 0 :max 20) 4) (add-preference :appearance :box-font "Text font" :font (om-def-font :normal)) (add-preference :appearance :box-align "Text align" '(:left :center :right) :center) (add-preference :appearance :box-icon "Icon position" '(:left :top :noicon) :left) ;;;============================= ; DEPENDENCY/DOCUMENT MANAGEMENT ;;;============================= (defmethod find-persistant-container ((self OMBox)) (let ((container (container self))) (if container (or (is-persistant container) (let ((one-box-ref (find-if #'(lambda (b) (subtypep (type-of b) 'OMBox)) (references-to container)))) (and one-box-ref (find-persistant-container one-box-ref)))) (om-beep-msg "ERROR :: Could not find any parent document!")) )) ;;;============================= ; PROPERTIES ;;;============================= (defmethod object-name-in-inspector ((self OMBox)) (string+ (string-upcase (format nil "~A" (reference self))) " box")) ;;; id text type slot-name (defmethod get-properties-list ((self OMBox)) `(("Appearance" ;;; category (:color "Color" :color-or-nil color (:appearance :box-color)) (:border "Border" ,(make-number-or-nil :min 0 :max 4 :decimals 1) border (:appearance :box-border)) (:roundness "Corner" ,(make-number-or-nil :min 0 :max 20) roundness (:appearance :box-roundness)) (:text-font "Text font" :font-or-nil text-font (:appearance :box-font)) (:align "Text align" (:left :center :right :default) text-align (:appearance :box-align)) ) ("Sequencer" ;;; category (:group-id "Group/Track" (:none 1 2 3 4 5 6 7 8) group-id) ))) (defmethod consolidate-appearance ((self OMBox)) (set-property self :color (make-color-or-nil :t-or-nil t :color (box-draw-color self))) (set-property self :border (make-number-or-nil :t-or-nil t :number (box-draw-border self))) (set-property self :roundness (make-number-or-nil :t-or-nil t :number (box-draw-roundness self))) (set-property self :text-font (make-font-or-nil :t-or-nil t :font (box-draw-font self))) (set-property self :align (box-draw-text-align self)) (when (valid-property-p self :icon) (set-property self :icon (box-draw-icon-pos self))) ) (defmethod box-draw-color ((box OMBox)) (if (color-? (color box)) (color-color (color box)) (get-pref-value :appearance :box-color))) (defmethod box-draw-font ((box OMBox)) (if (font-? (text-font box)) (font-font (text-font box)) (get-pref-value :appearance :box-font))) (defmethod box-draw-text-color ((box OMBox)) (if (color-? (text-color box)) (color-color (text-color box)) (om-def-color :black))) (defmethod box-draw-text-align ((box OMBox)) (or (text-align box) (get-pref-value :appearance :box-align))) (defmethod box-draw-border ((box OMBox)) (if (number-? (border box)) (number-number (border box)) (get-pref-value :appearance :box-border))) (defmethod box-draw-roundness ((box OMBox)) (if (number-? (roundness box)) (number-number (roundness box)) (get-pref-value :appearance :box-roundness))) (defmethod box-draw-icon-pos ((box OMBox)) (or (icon-pos box) (get-pref-value :appearance :box-icon))) (defmethod update-container-groups ((self t)) self) (defmethod set-property ((object OMBox) (prop-id (eql :group-id)) val) (call-next-method) (when (container object) (update-container-groups (container object)))) (defmethod set-property ((object OMBox) (prop-id (eql :icon)) val) (let ((old-value (get-property object prop-id))) (call-next-method) (unless (equal old-value val) (initialize-size object)) )) ;;;============================= (defgeneric gen-code (box &optional numout) (:documentation "Used to generate Lisp code from a box call.")) (defgeneric* omng-box-value (box &optional numout) (:documentation "Eval the output indexed by <numout> for the box <self>.")) (defmethod current-box-value ((self OMBox) &optional (numout nil)) (if numout (nth numout (value self)) (value self))) (defmethod omng-box-value ((self OMBox) &optional numout) (current-box-value self)) (defmethod initialize-box-value ((self OMBox) &optional value) (setf (value self) nil) (when (frame self) (om-invalidate-view (frame self)))) (defmethod set-value ((self OMBox) value) (setf (value self) value)) (defmethod get-box-value ((self OMBox)) (car (value self))) (defmethod set-box-outputs ((self OMBox) outputs) (setf (outputs self) outputs) (when (container self) (report-modifications (editor (container self))))) (defmethod set-box-inputs ((self OMBox) inputs) (setf (inputs self) inputs) (when (container self) (report-modifications (editor (container self))))) (defmethod set-show-name ((box OMBox)) (when (visible-property (get-properties-list box) :showname) (setf (show-name box) (not (show-name box))) (update-inspector-for-object box) (om-invalidate-view (frame box)))) (defmethod initialize-instance :after ((self OMBox) &rest args) (setf (inputs self) (create-box-inputs self)) (setf (outputs self) (create-box-outputs self))) (defmethod create-box-inputs ((self OMBox)) nil) (defmethod box-n-outs ((self OMBox)) (length (outputs self))) (defmethod create-box-outputs ((self OMBox)) nil) ;;; some boxes can not be renames (ex. functions) (defmethod allow-rename ((self OMBox)) t) (defmethod get-box-frame-class ((self OMBox)) 'OMBoxFrame) ;;; applies to the NG Box but must be done when the frames are in place.. ;;; (because it uses the positions of the frame areas) (defmethod update-connections ((self OMBox)) (mapcar #'(lambda (c) (update-points c) (update-graphic-connection c)) (get-box-connections self))) (defmethod omng-move ((self OMBox) position) (setf (box-x self) (om-point-x position) (box-y self) (om-point-y position)) ;(update-connections self) (when (container self) (report-modifications (editor (container self))))) ;;; will be defined for OMBoxFrame (defmethod move-frame-to-position ((self t) (container-view t) position) nil) (defmethod resize-frame-to-size ((self t) (container-view t) size) nil) (defmethod update-frame-to-box-position ((self OMBox)) (move-frame-to-position (frame self) (om-view-container (frame self)) (omp (box-x self) (box-y self)))) (defmethod update-frame-to-box-size ((self OMBox)) (resize-frame-to-size (frame self) (om-view-container (frame self)) (omp (box-w self) (box-h self)))) ;;; sometimes there is no boxframe at all (e.g. in sequencer tracks) (defmethod update-frame-to-box-position ((self t)) nil) (defmethod update-frame-to-box-size ((self t)) nil) (defmethod move-box-to ((self OMBox) x y) (omng-move self (om-make-point x y)) (when (frame self) (update-frame-to-box-position self)) (update-connections self)) (defmethod move-box ((self OMBox) dx dy) (move-box-to self (max 0 (+ (box-x self) dx)) (max 0 (+ (box-y self) dy)))) ;;; Does the box scale if placed in a timed view (e.g. a sequencer track) (defmethod scale-in-x-? ((self OMBox)) t) (defmethod scale-in-y-? ((self OMBox)) t) (defmethod omng-resize ((self OMBox) size) (setf (box-w self) (om-point-x size) (box-h self) (om-point-y size)) (mapcar 'update-points (get-box-connections self)) (when (container self) (report-modifications (editor (container self))))) ;;; e.g. in sequencer-track-view (defmethod reset-frame-size ((frame t)) nil) (defmethod redraw-connections ((self t)) nil) (defmethod initialize-size ((self OMBox)) (let ((size (default-size self))) (omng-resize self size) (when (frame self) (reset-frame-size (frame self)) (om-invalidate-view (frame self)) (redraw-connections (frame self))))) (defmethod minimum-size ((self OMBox)) (multiple-value-bind (w h) (om-string-size (name self) (box-draw-font self)) (om-make-point (+ 10 (max (+ 8 w (if (equal (box-draw-icon-pos self) :left) 20 0)) 22 (* (length (inputs self)) 10) (* (box-n-outs self) 10))) (+ h 16 (if (equal (box-draw-icon-pos self) :top) 20 0)) ))) (defmethod maximum-size ((self OMBox)) (multiple-value-bind (w h) (om-string-size (name self) (box-draw-font self)) (declare (ignore w)) (if (equal (box-draw-icon-pos self) :left) (om-make-point 500 (max (+ (get-icon-size self) 8) (+ h 16))) (om-make-point 500 200)))) (defmethod default-size ((self OMBox)) (minimum-size self)) (defmethod get-icon-id ((self t)) nil) (defmethod get-update-frame ((self OMBox)) (frame self)) (defmethod select-box ((self OMBox) selected) (unless (equal (selected self) selected) (setf (selected self) selected) (when (frame self) (om-invalidate-view (frame self)) (let ((ed (and (om-view-window (frame self)) (editor (om-view-window (frame self)))))) (when ed (update-inspector-for-editor ed)) )))) (defmethod redraw-frame ((self OMBox)) (when (frame self) (om-invalidate-view (frame self)))) (defmethod editor-box-selection ((editor OMEditor) (box OMBox)) (unless (or (om-shift-key-p) (selected box)) (select-unselect-all editor nil)) (if (om-shift-key-p) (select-box box (not (selected box))) (unless (selected box) (select-box box t)) )) (defmethod editor-box-selection ((editor OMEditor) (box null)) (unless (om-shift-key-p) (select-unselect-all editor nil))) ;;;=========================== ;;; ALIGN TOOL: auto-set position ;;;=========================== ;; a simple box alignment utility ;; tries to best-guess according to proximity with neighbour boxes' borders, ;; and with box connections ;;; works only if the box is visible on screen (defmethod align-box ((self OMBox)) (labels ( (box-x2 (b) (+ (box-x b) (box-w b))) (box-y2 (b) (+ (box-y b) (box-h b))) (overlap-in-x (b1 b2) (and (> (box-x2 b1) (box-x b2)) (< (box-x b1) (box-x2 b2)))) (overlap-in-y (b1 b2) (and (> (box-y2 b1) (box-y b2)) (< (box-y b1) (box-y2 b2)))) (farther-in-x (b1 b2 dist) (or (> (- (box-x b2) (box-x2 b1)) dist) (> (- (box-x b1) (box-x2 b2)) dist))) (farther-in-y (b1 b2 dist) (or (> (- (box-y b2) (box-y2 b1)) dist) (> (- (box-y b1) (box-y2 b2)) dist))) (overlap (b1 b2) (and (overlap-in-x b1 b2) (overlap-in-y b1 b2))) ) (let ((other-boxes (remove self (boxes (container self)))) (threshold 20) (scope 100) (smallest-dx nil) (smallest-dy nil)) ;;; (try to) DE-OVERLAP (unless (subtypep (type-of self) 'OMComment) ;;; do not de-overlap comments... (loop for box in (remove-if #'(lambda (b) (subtypep (type-of b) 'OMComment)) other-boxes) do (when (overlap self box) (if (or (<= (box-y self) (box-y box)) (is-connected-up-to box self)) ;;; always move up if the boxes are connected ;;; move-up (move-box-to self (box-x self) (- (box-y box) (box-h self) 2)) ;;; move down (move-box-to self (box-x self) (+ (box-y2 box) 2))) ))) ;;; find de smallest connection deviation (loop for inp in (inputs self) do (when (connections inp) ;; only 1 max (let ((dx (- (om-point-x (io-position-in-patch (area (from (car (connections inp)))))) (om-point-x (io-position-in-patch (area inp)))))) (when (or (null smallest-dx) (< (abs dx) (abs smallest-dx))) (setf smallest-dx dx)) )) ) (when (or (null smallest-dx) (> (abs smallest-dx) threshold)) (loop for outp in (outputs self) do (loop for c in (connections outp) do (let ((dx (- (om-point-x (io-position-in-patch (area (to c)))) (om-point-x (io-position-in-patch (area outp)))))) (when (or (null smallest-dx) (< (abs dx) (abs smallest-dx))) (setf smallest-dx dx)) )) ) ) ;;; X-ALIGNMENT ;;; find de closest top/bottom neighbour box x-deviation (with left and right borders) (when (or (null smallest-dx) (> (abs smallest-dx) threshold)) (loop for box in (remove-if #'(lambda (b) (or (overlap-in-y b self) (farther-in-y b self scope))) other-boxes) do (let ((dx1 (- (box-x box) (box-x self))) (dx2 (- (box-x2 box) (box-x2 self)))) (when (or (null smallest-dx) (< (abs dx1) (abs smallest-dx))) (setf smallest-dx dx1)) (when (< (abs dx2) (abs smallest-dx)) (setf smallest-dx dx2))) ) ) ;;; Y-ALIGNMENT ;;; find the closest left-right nighbour deviation (with top and bottom) (loop for box in (remove-if #'(lambda (b) (or (overlap-in-x b self) (farther-in-x b self scope))) other-boxes) do (let ((dy1 (- (box-y box) (box-y self))) (dy2 (- (box-y2 box) (box-y2 self)))) (when (or (null smallest-dy) (< (abs dy1) (abs smallest-dy))) (setf smallest-dy dy1)) (when (< (abs dy2) (abs smallest-dy)) (setf smallest-dy dy2))) ) (move-box self (or (and smallest-dx (< (abs smallest-dx) threshold) smallest-dx) 0) (or (and smallest-dy (< (abs smallest-dy) threshold) smallest-dy) 0)) ))) ;;;=========================== ;;; CHACHE DISPLAY SYSTEM ;;;=========================== (defstruct cache-display (text) (draw)) ;;; shorthands (defmethod get-display-text ((self OMBox)) (cache-display-text (cache-display self))) (defmethod get-display-draw ((self OMBox)) (cache-display-draw (cache-display self))) ;;; to be redefined by objects if they have a specific draw/cache strategy (defmethod get-cache-display-for-text ((object t) box) (declare (ignore box)) (loop for sl in (append (mapcar 'slot-name (remove-if-not 'slot-initargs (class-direct-instance-slots (class-of object)))) (additional-class-attributes object)) collect (list sl (let ((val (get-slot-val object sl))) (if (and (listp val) (> (length val) 10)) (append (first-n val 10) '("...")) val))))) ;;; to be redefined by objects if they have a specific draw/cache strategy (defmethod get-cache-display-for-draw ((object t) box) nil) ;;; never called (just verify for collection editors, where the cache-display must be set several times) ;(defmethod set-cache-display ((self OMBox) object) ; (setf (cache-display self) ; (make-cache-display :text (get-cache-display-for-text object) ; :draw (get-cache-display-for-draw object box)))) (defmethod reset-cache-display ((self OMBox)) (setf (cache-display self) nil)) (defmethod ensure-cache-display-text (box object) (if (cache-display box) (or (cache-display-text (cache-display box)) (setf (cache-display-text (cache-display box)) (get-cache-display-for-text object box))) (progn (setf (cache-display box) (make-cache-display :text (get-cache-display-for-text object box))) (cache-display-text (cache-display box))))) (defmethod ensure-cache-display-draw (box object) (if (cache-display box) (or (cache-display-draw (cache-display box)) (setf (cache-display-draw (cache-display box)) (get-cache-display-for-draw object box))) (progn (setf (cache-display box) (make-cache-display :draw (get-cache-display-for-draw object box))) (cache-display-draw (cache-display box)))))

Common Lisp

.lisp

cac-t-u-s/om-sharp

GPL-3.0

9/19/2024, 11:25:22 AM (Europe/Amsterdam)

6b9e083a3f1524e0caa0af92c24ebbae7ea4df2dcd69accc264518f57f213f05

gen-code.lisp

cac-t-u-s_om-sharp/src/visual-language/patch/gen-code.lisp

;============================================================================ ; om#: visual programming language for computer-assisted music composition ;============================================================================ ; ; This program is free software. For information on usage ; and redistribution, see the "LICENSE" file in this distribution. ; ; This program 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. ; ;============================================================================ ; File author: J. Bresson ;============================================================================ ;======================================== ; LISP CODE GENERATION ; - most of thso part taken from OM6 ;======================================== (in-package :om) ;;; Produces a (unique) name for a box (defmethod gen-box-name ((self OMBox)) (read-from-string (string+ "box-" (substitute #\- #\Space (name self)) (format () "~3,'0d~3,'0d" (box-x self) (box-y self))) )) ;;;================= ;;; CONSTANT GEN-CODES ;;;================= (defmethod gen-code ((self t) &optional numout) (declare (ignore numout)) self) (defmethod gen-code ((self symbol) &optional numout) (declare (ignore numout)) `',self) (defmethod gen-code ((self null) &optional numout) (declare (ignore numout)) nil) ;generate code for list (defmethod gen-code ((self list) &optional numout) (declare (ignore numout)) (let ((sizelimit 2047)) (if (> (length self) sizelimit) (let* ((tmp (copy-list self)) (split (loop while tmp collect (loop for n from 1 to sizelimit while tmp collect (pop tmp))))) `(append ,.(mapcar #'(lambda (x) (gen-code x)) split))) `(list ,.(mapcar #'(lambda (x) (gen-code x)) self)) ))) ;;;================= ;;; BOX INPUTS ;;;================= (defun flat-quotes (list) (mapcar #'(lambda (val) (if (quoted-form-p val) (eval val) val)) list)) (defmethod gen-code-inputs ((self OMBoxCall)) "Generation of Lisp code for inputs of <self>." (append (loop for input in (remove-if #'(lambda (item) (subtypep item 'box-keyword-input)) (inputs self) :key 'type-of) collect (gen-code input)) (gen-code-keywords self))) (defmethod gen-code-keywords ((self OMBoxcall)) (loop for key-in in (get-keyword-inputs self) append (list (intern-k (name key-in)) (gen-code key-in)))) (defmethod gen-code ((self box-input) &optional numout) (declare (ignore numout)) (if (connections self) ;;; in principle there is only 1 connection (let* ((output (from (car (connections self)))) (box (box output)) (numout (position output (outputs box)))) (gen-code box numout)) (gen-code (value self)))) ;;;================= ;;; INPUT BOX ;;;================= (defmethod gen-code ((self OMOutBox) &optional numout) (declare (ignore numout)) (gen-code (car (inputs self)))) ;;;================= ;;; INPUT BOX ;;;================= (defmethod gen-code ((self OMInBox) &optional numout) (declare (ignore numout)) (in-symbol (reference self))) ;;;================= ;;; GENERAL ;;;================= (defvar *freeze-eval-once-mechanism* NIL) (defmethod gen-code ((self OMBoxCall) &optional numout) "Generate Lisp code for the box <self> evaluated at <numout>." ; (print (list "gen-code" (name self))) (cond ((equal (lock-state self) :locked) (gen-code-locked self numout)) ((or (equal (lock-state self) :eval-once) (and (get-pref-value :general :auto-ev-once-mode) (not *freeze-eval-once-mechanism*) (> (length (get-out-connections self)) 1) )) (gen-code-for-ev-once self numout)) (t (gen-code-for-eval self numout)) )) (defmethod gen-code-locked ((self OMBoxCall) numout) (case (lambda-state self) (:reference `',(reference self)) (:box `,self) (otherwise (if numout (gen-code (nth numout (value self))) (value self))) )) (defmethod gen-code-locked ((self OMBoxRelatedWClass) numout) (prepare-obj-for-request (car (value self)) self) (if (lambda-state self) ;; :box or :reference (call-next-method) (if (or (null numout) (= 0 numout)) (gen-code (car (value self))) `(get-slot-val ,(gen-code (car (value self))) ,(name (nth numout (outputs self))))))) ;;; NOT LOCKED / FIRST EVAL-ONCE (defmethod gen-code-for-eval ((self OMBoxCall) &optional numout) (case (lambda-state self) (:reference `',(reference self)) (:box (let ((value nil)) (setf (lambda-state self) nil) (setf value `(list .,(multiple-value-list (gen-code self)))) (setf (lambda-state self) :box) `(progn (setf (value ,self) ,value) ,self)) ) (:lambda ;(if (or (null numout) ;;; we are iside a let / ev-once statement : return all as 'values' ; (= (length (outputs self)) 1)) ;; single output (to simplify the code) ; `,(gen-code-lambda self) ; `(nth ,numout (multiple-value-list ,(gen-code-lambda self)))) `,(gen-code-lambda self numout)) (otherwise (if (or (null numout) ;;; we are inside a let / ev-once statement : return all as 'values' (= (length (outputs self)) 1)) ;; single output (to simplify the code) `,(gen-code-for-call self) ;;; normal call (not ev-once) and several outputs `(nth ,numout (multiple-value-list ,(gen-code-for-call self))) )) )) (defmethod gen-code-for-eval ((self OMBoxRelatedWClass) &optional numout) (if (lambda-state self) ;; :box or :reference (call-next-method) (if (or (null numout) ;;; we are inside a let / ev-once statement : return all as 'values' (= numout 0)) ;; first output `,(gen-code-for-call self) `(get-slot-val ,(gen-code-for-call self) ,(name (nth numout (outputs self)))) ))) ;;;================= ;;; Eval Once ;;;================= ;;; EV-ONCE APPLIES AS A "LET" WHEN A BOX IS CONNECTED TO SEVERAL DESCENDANTS ;;; OR TO A REPEAT-N BOX (defparameter *let-list-stack* nil) (defun push-let-context (&optional (context nil)) (push context *let-list-stack*)) (defun pop-let-context () (pop *let-list-stack*)) (defun output-current-let-context () ; (print (list "LET OUTPUT" *let-list-stack*)) (reverse (car *let-list-stack*))) (defun empty-current-let-context () (null (car *let-list-stack*))) (defun push-let-statement (form &optional (scope :local)) ;(print (list "PUSH LET IN" form scope *let-list-stack*)) (if *let-list-stack* (if (or (equal scope :local) (= 1 (length *let-list-stack*))) ;;; add the let statment to the head of the stack (setf (car *let-list-stack*) (cons form (car *let-list-stack*))) ;;; add the let statment to the previous position of the stack ;;; = higher-level context ;;; this is used essentially for gloval variables used in loops ;;; (loop has its own context within the patch) (setf (cadr *let-list-stack*) (cons form (cadr *let-list-stack*))) ;;; top-level: not good in case of nested abstractions ;(setf (car (last *let-list-stack*)) ; (cons form (car (last *let-list-stack*)))) ) ;;; create a new stack (setq *let-list-stack* (list (list form))) ) ) (defun check-let-statement (varname &optional (scope :local)) ;(print (list "CHECK LET IN" varname *let-list-stack*)) (if (equal scope :local) (member varname (car *let-list-stack*) :test 'equal :key 'car) (member varname (apply 'append *let-list-stack*) :test 'equal :key 'car))) ;;; PUSHES IN THE LET-LIST: ;;; - A LIST IF MULTIPLE OUTPUTS ;;; - A SIMPLE ELEMENT IF ONE OUTPUT (defmethod gen-code-for-ev-once ((self OMBoxCall) numout) (let* ((varname (gen-box-name self)) (newvar? (not (check-let-statement varname :local)))) (if (> (length (outputs self)) 1) (progn (when newvar? (push-let-statement `(,varname (multiple-value-list ,(gen-code-for-eval self nil)))) ) (if numout ;;; in principle numout = NIL happens only when we generate the Lisp code for display `(nth ,numout ,varname) varname)) (progn (when newvar? (push-let-statement `(,varname ,(gen-code-for-eval self 0))) ) `,varname) ))) (defmethod gen-code-for-ev-once ((self OMBoxRelatedWClass) numout) (let* ((varname (gen-box-name self)) (newvar? (not (check-let-statement varname :local)))) (when newvar? (push-let-statement `(,varname ,(gen-code-for-eval self nil)))) (if (= numout 0) `,varname `(get-slot-val ,varname ,(name (nth numout (outputs self)))) ))) ;;;================= ;;; Standard call code generation ;;;================= (defmethod gen-code-for-call ((self OMFunBoxcall) &optional args) (let ((arguments (or args (gen-code-inputs self)))) `(,(reference self) ,.arguments))) (defmethod gen-code-for-call ((self OMBoxAbstraction) &optional args) (let ((fun `,(intern (string (compiled-fun-name (reference self))) :om)) (arguments (or args (gen-code-inputs self)))) (compile-if-needed (reference self)) `(funcall ',fun ,.arguments))) (defmethod gen-code-for-call ((self OMValueBox) &optional args) (declare (ignore args)) (if (inputs self) (if (= 1 (length (inputs self))) `,(car (gen-code-inputs self)) `(list ,.(gen-code-inputs self))) (gen-code (car (value self))))) (defmethod gen-code-for-call ((self OMBoxEditCall) &optional args) (declare (ignore args)) (let ((self-in (gen-code (car (inputs self))))) (if self-in (let ((c-args (get-connected-args self #'gen-code))) (if c-args `(make-value-from-model ',(reference self) ,self-in (list ,.(mapcar #'(lambda (arg) `(list ,(intern-k (car arg)) ,(cadr arg))) c-args))) `(make-value-from-model ',(reference self) ,self-in nil))) `(make-value ',(reference self) (list ,.(mapcar #'(lambda (arg) `(list ,(intern-k (car arg)) ,(cadr arg))) (get-all-args self #'gen-code))))))) (defmethod gen-code-for-call ((self OMSlotsBox) &optional args) `(let ((obj ,(gen-code (car (inputs self))))) (when obj (set-value-slots obj (list ,. ;(mapcar #'(lambda (arg) `(list ,(intern-k (car arg)) ,(cadr arg))) (mapcar #'(lambda (arg) `(list ,(symbol-name (car arg)) ,(cadr arg))) (get-connected-args self #'gen-code)) )) obj))) ;;;================= ;;; Lambda ;;;================= ;;; RETURN VALUES FOR THE DIFFERENT OUTPUTS (defmethod gen-code-lambda ((self OMBoxcall) &optional numout) (multiple-value-bind (new-symbs args) (get-args-eval-curry self #'gen-code) (let ((box-code (gen-code-for-call self (apply 'append args)))) ; `(funcall ',(reference self) ,.(apply 'append args)))) (if (> (length (outputs self)) 1) (if numout ;; one specific output function is requested `#'(lambda ,new-symbs (nth ,numout (multiple-value-list ,box-code))) ;; all functions requested (LET/EV-ONCE) `(values .,(loop for n from 0 to (1- (length (outputs self))) collect `#'(lambda ,new-symbs (nth ,n (multiple-value-list ,box-code)))))) ;; single output `#'(lambda ,new-symbs ,box-code))))) ;;;============================= ;;; MAIN COMPILATION FUNCTION ;;;============================= (defmethod gen-input-name ((in OMIn)) (read-from-string (string+ (format () "in~D_" (index in)) (substitute #\_ #\Space (name in))))) (defmethod gen-patch-input-names ((self OMPatch)) (mapcar #'(lambda (in) (setf (in-symbol in) (gen-input-name in))) (sort (get-inputs self) '< :key 'index)) ) (defmethod gen-patch-lisp-code ((self OMPatch)) ;(print (list "GEN CODE" (name self) *let-list-stack*)) (push-let-context) (unwind-protect (let* ((input-names (gen-patch-input-names self)) ;;; OMPatchInitBox have no index... ? (init-boxes (sort-boxes (get-boxes-of-type self 'OMPatchInitBox))) (init-forms (loop for ib in init-boxes append (gen-code ib))) (loop-boxes (sort-boxes (get-boxes-of-type self 'OMPatchIteratorBox))) (loop-forms (loop for lb in loop-boxes append (gen-code lb))) (out-boxes (sort-boxes (get-boxes-of-type self 'OMOutBox))) (body (if (> (length out-boxes) 1) `(values ,.(mapcar #'(lambda (out) (gen-code out)) out-boxes)) (gen-code (car out-boxes))))) ;;; return this (values input-names (if (empty-current-let-context) (if (or init-forms loop-forms) `(progn ,.init-forms ,.loop-forms ,body) body) `(let* ,(output-current-let-context) ,.init-forms ,.loop-forms ,body) )) ) ;; cleanup (pop-let-context) ) ) (defmethod get-patch-lambda-expression ((self OMPatch)) (multiple-value-bind (input-names body) (ignore-errors (gen-patch-lisp-code self)) `(lambda (,.input-names) ,body))) ;;; compile : a fonction with N inputs and M outputs ;;; (with tempin = 1st input / tempout = 1st output, if they exist) (defmethod compile-patch ((self OMPatch)) ;; set the flag before in case of recursive patch! (setf (compiled? self) t) (handler-bind () ;((error #'(lambda (err) ; ; (om-print err) ; (om-print-format "ABORTING COMPILATION OF PATCH ~A" (list (name self)) "[!!]") ; ; (setf (compiled? self) nil) ; ; (abort-eval) ; (error err) ; ))) (multiple-value-bind (input-names body) (gen-patch-lisp-code self) (let ((f-def `(defun ,(intern (string (compiled-fun-name self)) :om) (,.input-names) ,body))) ;(om-print-format "~%------------------------------------------------------~%PATCH COMPILATION: ~A ~%" (list (compiled-fun-name self))) ;(write f-def :stream om-lisp::*om-stream* :escape nil :pretty t) ;(om-print-format "~%------------------------------------------------------~%~%") (compile (eval f-def)))) ) ) #| (defmethod curry-lambda-code ((self OMBoxEditCall) symbol) "Lisp code generetion for a factory in lambda mode." (let* ((nesymbs nil) (args (mapcar #'(lambda (input) (if (connected? input) (gen-code input 0) (let ((newsymbol (gensym))) (push newsymbol nesymbs) newsymbol))) (inputs self)))) (cond ((connected? (first (inputs self))) `#'(lambda () (objFromObjs ,(first args) (make-instance ',symbol)))) ((= (length nesymbs) (length args)) `#'(lambda ,(reverse nesymbs) (cons-new-object (make-instance ',symbol) (list ,. args) nil))) (t `#'(lambda ,(cdr (reverse nesymbs)) (cons-new-object (make-instance ',symbol) (list nil ,.(cdr args)) nil)))))) |#

Common Lisp

.lisp

cac-t-u-s/om-sharp

GPL-3.0

9/19/2024, 11:25:22 AM (Europe/Amsterdam)

2ae9f57418679287464e696e13a05e641307599167f5f98fc237a5585c98934f

meta-inputs.lisp

cac-t-u-s_om-sharp/src/visual-language/patch/meta-inputs.lisp

;============================================================================ ; om#: visual programming language for computer-assisted music composition ;============================================================================ ; ; This program is free software. For information on usage ; and redistribution, see the "LICENSE" file in this distribution. ; ; This program 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. ; ;============================================================================ ; File author: J. Bresson ;============================================================================ ;;; META INPUTS: ;;; These boxes nust be updated before evaluation, depending on their call context ;;; The 'meta' inputs DO NOT APPEAR as box inlets outside the patch (defclass OMMetaIn (OMIn) ()) (defmethod register-patch-io ((self OMPatch) (elem OMMetaIn)) (setf (index elem) 0) (setf (defval elem) nil)) ;;; doesn't impact other inputs (defmethod unregister-patch-io ((self OMPatch) (elem OMMetaIn)) nil) (defclass OMMetaInBox (OMInBox) ()) (defmethod io-box-icon-color ((self OMMetaInBox)) (om-make-color 0.6 0.2 0.2)) (defmethod next-optional-input ((self OMMetaInBox)) nil) (defmethod related-patchbox-slot ((self OMMetaInBox)) nil) (defmethod allow-text-input ((self OMMetaInBox)) nil) ;;;==================================== ;;; THIS BOX ;;;==================================== (defclass OMSelfIn (OMMetaIn) () (:documentation "Returns the box containing this patch.")) (defclass OMSelfInBox (OMMetaInBox) ()) (defmethod special-box-p ((name (eql 'thisbox))) t) (defmethod get-box-class ((self OMSelfIn)) 'OMSelfInBox) (defmethod box-symbol ((self OMSelfIn)) 'thisbox) (defmethod special-item-reference-class ((item (eql 'thisbox))) 'OMSelfIn) (defmethod omNG-make-special-box ((reference (eql 'thisbox)) pos &optional init-args) (omNG-make-new-boxcall (make-instance 'OMSelfIn :name "THIS BOX") pos init-args)) (defmethod box-container ((self OMBox)) (box-container (container self))) ;;; if there are several references (OMPatchFile) ;;; we assume that the first in the list is the current caller ;;; this is set by omng-box-value :before (defmethod box-container ((self OMPatch)) (car (box-references-to self))) ;;; BOX VALUE (defmethod omNG-box-value ((self OMSelfInBox) &optional (numout 0)) (set-value self (list (box-container self))) (return-value self numout)) (defmethod gen-code ((self OMSelfInBox) &optional (numout 0)) (set-value self (list (box-container self))) (nth numout (value self))) ;;;==================================== ;;; THIS PATCH ;;;==================================== (defclass OMPatchIn (OMMetaIn) () (:documentation "Returns the Patch containing this patch/subpatch.")) (defclass OMPatchInBox (OMMetaInBox) ()) (defmethod special-box-p ((name (eql 'thispatch))) t) (defmethod get-box-class ((self OMPatchIn)) 'OMPatchInBox) (defmethod box-symbol ((self OMPatchIn)) 'thispatch) (defmethod special-item-reference-class ((item (eql 'thispatch))) 'OMPatchIn) (defmethod omNG-make-special-box ((reference (eql 'thispatch)) pos &optional init-args) (omNG-make-new-boxcall (make-instance 'OMPatchIn :name "THIS PATCH") pos init-args)) (defmethod omNG-box-value ((self OMPatchInBox) &optional (numout 0)) (set-value self (list (container self))) (return-value self numout)) (defmethod gen-code ((self OMPatchInBox) &optional (numout 0)) (set-value self (list (container self))) (nth numout (value self)))

Common Lisp

.lisp

cac-t-u-s/om-sharp

GPL-3.0

9/19/2024, 11:25:22 AM (Europe/Amsterdam)

fb78f4c9bead47bd2470490f140f6a5921099d42cb84912d1427fcc0f4e4b00f

boxsimple.lisp

cac-t-u-s_om-sharp/src/visual-language/patch/boxsimple.lisp

;============================================================================ ; om#: visual programming language for computer-assisted music composition ;============================================================================ ; ; This program is free software. For information on usage ; and redistribution, see the "LICENSE" file in this distribution. ; ; This program 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. ; ;============================================================================ ; File author: J. Bresson ;============================================================================ ;========================================================================= ;;; SIMPLE VALUE BOX ;;;==================================================== (in-package :om) (defclass OMValueBox (OMBoxCall) () (:metaclass omstandardclass) (:default-initargs :icon-pos :noicon)) (defmethod get-object-type-name ((self OMValueBox)) "Simple value") (defmethod get-properties-list ((self OMValueBox)) (hide-properties (call-next-method) '(:group-id :lambda))) (defmethod create-box-outputs ((self OMValueBox)) (list (make-instance 'box-output :box self :name "value"))) (defmethod next-optional-input ((self OMValueBox)) t) (defmethod more-optional-input ((self OMValueBox) &key name (value nil val-supplied-p) doc reactive) (declare (ignore name doc)) (unless nil ; (inputs self) (add-optional-input self :name "in" :value (if val-supplied-p value nil) :doc "set box value" :reactive reactive) t)) (defmethod omNG-make-new-boxcall ((reference (eql 'value)) pos &optional init-args) (let* ((box (make-instance 'OMValueBox :name "value box" :reference (type-of init-args) ;;; by default these boxes are white.. :color (make-color-or-nil :color (om-def-color :white) :t-or-nil t) ))) (setf (value box) (list init-args) (box-x box) (om-point-x pos) (box-y box) (om-point-y pos) (inputs box) nil) (let ((size (om-max-point (minimum-size box) (default-size box)))) (setf (box-w box) (om-point-x size) (box-h box) (om-point-y size))) box)) (defmethod print-value ((self OMValueBox)) (format nil "~s" (car (value self)))) (defmethod object-name-in-inspector ((self OMValueBox)) "Value box") (defmethod get-documentation ((self OMValueBox)) (format nil "Current value of type ~A.~%~%Use +/- to add/remove inputs.~%Double-click to edit contents." (string-upcase (reference self)))) (defmethod default-size ((self OMValueBox)) (multiple-value-bind (tw th) (om-string-size (print-value self) (box-draw-font self)) (om-make-point (max (min (+ tw 18) 500) (+ 20 (* (length (inputs self)) 10)) 32) (+ th 16)))) (defmethod maximum-size ((self OMValueBox)) (omp 1000 1000)) (defmethod minimum-size ((self OMValueBox)) (multiple-value-bind (tw th) (om-string-size (print-value self) (box-draw-font self)) (declare (ignore tw)) (om-make-point (max ; (+ tw 18) (+ 20 (* (length (inputs self)) 10)) 32) (max (+ th 16) 28)))) ;;; Does the box scale if placed in a timed view (e.g. a sequencer track) (defmethod scale-in-x-? ((self OMValueBox)) nil) (defmethod scale-in-y-? ((self OMValueBox)) nil) (defmethod allow-text-input ((self OMValueBox)) (values (format nil "~s" (car (value self))) #'(lambda (box text) (handler-bind ((error #'(lambda (error) (declare (ignore error)) (om-beep) (abort-eval)))) ;;(setf (name box) text) (let ((val (ignore-errors (read-from-string text)))) (set-value box (list (if (quoted-form-p val) (eval val) val))) ))) )) (defmethod om-copy ((self OMValueBox)) (let ((newbox (call-next-method))) ;;; add the optional/keywords (setf (value newbox) (om-copy (value self))) newbox)) (defmethod initialize-box-value ((self OMValueBox) &optional value) nil) (defmethod editable-on-click ((self OMValueBox)) nil) ;;;======================== ;;; BOX FRAME ;;;======================== (defclass OMValueBoxFrame (OMBoxFrame) ()) (defmethod get-box-frame-class ((self OMValueBox)) 'OMValueBoxFrame) (defmethod display-text-and-area ((self OMValueBoxFrame)) (let ((font (or (box-draw-font (object self)) (om-get-font self)))) (multiple-value-bind (w h) (om-string-size (print-value (object self)) font) (values (print-value (object self)) (case (box-draw-text-align (object self)) (:center (max 6 (round (- (/ (w self) 2) (/ w 2))))) (:right (- (w self) w 8)) (otherwise 6)) 6 w h)))) ;;; drag-edit (defmethod om-view-click-handler ((self OMValueBoxFrame) position) (if (and (numberp (get-box-value (object self))) (or (om-action-key-down) (container-frames-locked (om-view-container self)))) (let* ((box (object self)) (curr-val (get-box-value box)) (ndec (multiple-value-bind (i d) (string-until-char (format nil "~D" curr-val) ".") (declare (ignore i)) (length d))) (fact (expt 10 ndec)) ) ;;; we use fact to perfom integer arithmetics and avoid floating point approximations (store-current-state-for-undo (editor (container box))) (om-init-temp-graphics-motion self position nil :motion #'(lambda (view pos) (let ((diff-y (- (om-point-y position) (om-point-y pos)))) #+macosx (when (om-shift-key-p) (setf diff-y (* diff-y 10))) (setf curr-val (/ (+ (* curr-val fact) diff-y) fact)) (setf position pos) (set-value box (list curr-val)) (om-invalidate-view view) )) :release #'(lambda (view pos) (declare (ignore view pos)) (report-modifications (editor (container box)))) )) (call-next-method))) (defmethod om-view-doubleclick-handler ((self OMValueBoxFrame) position) (unless (edit-lock (editor (om-view-container self))) (or (apply-in-area self 'click-in-area position) (multiple-value-bind (edittext action) (allow-text-input (object self)) (let* ((container-view (om-view-container self))) (edit-text-in-patch edittext self container-view action (omp 0 0) (omp (w self) (h self)) :multi-line t ;;; set in auto-resize mode only when the box is single-line :auto-resize (<= (om-height self) (om-point-y (minimum-size (object self)))) ) t)))))

Common Lisp

.lisp

cac-t-u-s/om-sharp

GPL-3.0

9/19/2024, 11:25:22 AM (Europe/Amsterdam)

3fa71aaca32e5ff628661554a32d9d93ab7434935636062c62bfeb38311e0c62

patch-component-boxes.lisp

cac-t-u-s_om-sharp/src/visual-language/patch/patch-component-boxes.lisp

;============================================================================ ; om#: visual programming language for computer-assisted music composition ;============================================================================ ; ; This program is free software. For information on usage ; and redistribution, see the "LICENSE" file in this distribution. ; ; This program 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. ; ;============================================================================ ; File author: J. Bresson ;============================================================================ ;=============================================================================== ; PATCH CONTROL COMPONENTS ; TOP-LEVEL PATCH-COMPOENNT CLASS ; Superclass for OMPatchIO, OMPatchInit, OMPatchIterator... ; Special boxes that do not represent a function or class, but a special patch behaviour ;================================ (in-package :om) (defclass OMPatchComponent (OMBasicObject) ()) (defclass OMPatchComponentBox (OMBoxCall) ()) (defmethod omNG-make-new-boxcall ((reference OMPatchComponent) pos &optional init-args) (let* ((box (make-instance (get-box-class reference) :name (name reference) :reference reference :color (make-color-or-nil :color (get-patch-component-box-def-color reference) :t-or-nil t) :icon-pos (or (getf init-args :icon-pos) :top) :text-align :center)) (size (minimum-size box))) (setf (box-x box) (om-point-x pos) (box-y box) (om-point-y pos) (box-w box) (om-point-x size) (box-h box) (om-point-y size)) box)) (defmethod save-box-reference ((self OMPatchComponentBox)) (box-symbol (reference self))) (defmethod get-patch-component-box-def-color ((self OMPatchComponent)) (om-make-color 0.82 0.85 0.7)) (defmethod h-resizable ((self OMPatchComponentBox)) t) (defmethod v-resizable ((self OMPatchComponentBox)) nil) (defmethod get-properties-list ((self OMPatchComponentBox)) (add-properties (hide-properties (call-next-method) '(:icon :lock :lambda :group-id)) "Appearance" '((:icon "Icon position" (:left :top) icon-pos)))) (defmethod object-name-in-inspector ((self OMPatchComponentBox)) (string+ (string-upcase (type-of (reference self))) " box")) (defmethod valid-property-p ((self OMPatchComponentBox) (prop-id (eql :lock))) nil) (defmethod valid-property-p ((self OMPatchComponentBox) (prop-id (eql :lambda))) nil) (defmethod minimum-size ((self OMPatchComponentBox)) (om-make-point (max 40 (+ 22 (om-string-size (name self) (box-draw-font self)) (if (equal (box-draw-icon-pos self) :left) 22 0)) (+ 20 (* (length (inputs self)) 10))) (+ (if (equal (box-draw-icon-pos self) :top) 14 0) 28))) (defmethod maximum-size ((self OMPatchComponentBox)) (om-make-point 500 (+ (if (equal (box-draw-icon-pos self) :top) 14 0) 28))) ;;;================================== ;;; PATCH-COMPONENT EVALUATION ;;; most patch components are just used as control and do not 'evaluate' themselves. ;;;================================== (defmethod boxcall-value ((self OMPatchComponentBox)) (values-list (mapcar #'omNG-box-value (inputs self)))) (defmethod gen-code-for-call ((self OMPatchComponentBox) &optional args) (declare (ignore args)) ;; only for lambda generation (mapcar 'gen-code (inputs self)))

Common Lisp

.lisp

cac-t-u-s/om-sharp

GPL-3.0

9/19/2024, 11:25:22 AM (Europe/Amsterdam)

fd6946909b11589b84bc013e2c04ab33d646ce49743df259dee67ef95d58324d

patch-editor.lisp

cac-t-u-s_om-sharp/src/visual-language/patch/patch-editor.lisp

;============================================================================ ; om#: visual programming language for computer-assisted music composition ;============================================================================ ; ; This program is free software. For information on usage ; and redistribution, see the "LICENSE" file in this distribution. ; ; This program 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. ; ;============================================================================ ; File author: J. Bresson ;============================================================================ (in-package :om) ;;;============================= ;;; EDITOR ;;;============================= (defclass patch-editor (OMDocumentEditor undoable-editor-mixin) ((editor-window-config :accessor editor-window-config :initarg :editor-window-config :initform nil))) (defmethod object-has-editor ((self OMPatch)) t) (defmethod get-editor-class ((self OMPatch)) 'patch-editor) (defmethod edit-lock ((self patch-editor)) ;; in case its an internal patch (e.g. in the sequencer) (let ((ed (or (container-editor self) self))) (lock (object ed)))) (defclass patch-editor-window (OMEditorWindow) ()) (defclass patch-editor-view (OMEditorView om-drop-view om-tt-view multi-view-editor-view) ((dragged-views :initform nil :accessor dragged-views))) ;; (defmethod om-window-resized ((self patch-editor-window) size) ;; (when (editor-window-config (editor self)) ;; (om-invalidate-view (print (car (om-subviews self)))))) (defmethod editor-window-class ((self patch-editor)) 'patch-editor-window) (defmethod editor-view-class ((self patch-editor)) 'patch-editor-view) (defmethod editor-view-bg-color ((self patch-editor)) (om-def-color :white)) (defmethod editor-view-scroll-params ((self patch-editor)) t) (defmethod editor-view-drawable ((self patch-editor)) t) (defmethod editor-window-init-size ((self patch-editor)) (omp 500 500)) (defmethod init-editor ((ed patch-editor)) (let ((patch (object ed))) (when (and (is-persistant patch) (not (loaded? patch))) (load-contents patch)) (retain-reference patch ed) (call-next-method))) ;;; the default location of the editor view ;;; can change, e.g. for a sequencer-editor (defmethod get-editor-view-for-action ((self patch-editor)) (main-view self)) ;; will fall here for a sequencer-editor (main-view is not a patch-editor-view) (defmethod put-patch-boxes-in-editor-view ((self OMPatch) (view t)) nil) (defmethod set-default-size-in-editor (box view) (let ((def-size (default-size box))) (unless (box-w box) (setf (box-w box) (if (scale-in-x-? box) (omng-w view (om-point-x def-size)) (om-point-x def-size)))) (unless (box-h box) (setf (box-h box) (if (scale-in-y-? box) (omng-h view (om-point-y def-size)) (om-point-y def-size)))) )) ;;; called when one box is added by a user action (defmethod add-box-in-patch-editor ((box OMBox) (view patch-editor-view)) (if (allowed-element (object (editor view)) box) (when (omNG-add-element (editor view) box) (set-default-size-in-editor box view) (let ((frame (make-frame-from-callobj box))) (omg-add-element view frame) (contextual-update box (container box)) (select-box box t) frame) ) (om-beep-msg "Boxes of type ~A are not allowed in ~A." (type-of box) (type-of (editor view))) )) ;;; called by the patch window initialization (defmethod put-patch-boxes-in-editor-view ((self OMPatch) (view patch-editor-view)) (mapc #'(lambda (box) (set-default-size-in-editor box view) (omg-add-element view (make-frame-from-callobj box))) (boxes self)) (mapc #'(lambda (c) (add-connection-in-view view c)) (connections self)) ) (defmethod init-editor-window ((editor patch-editor)) (call-next-method) (let ((patch (object editor))) (put-patch-boxes-in-editor-view patch (main-view editor)) (when (get-g-component editor :inspector) (or (update-inspector-for-editor editor) (set-inspector-contents (get-g-component editor :inspector) nil))) (add-lock-item editor (main-view editor)) (update-window-name editor) )) (defmethod get-grap-connections ((self patch-editor-view) &key only-selected) (if only-selected (remove nil (mapcar 'graphic-connection (remove-if-not 'selected (connections (object (editor self)))))) (remove nil (mapcar 'graphic-connection (connections (object (editor self))))))) (defmethod draw-patch-grid ((self patch-editor-view) &optional (d 50)) (om-with-fg-color (om-make-color .95 .95 .95) ;(om-with-line '(2 2) ;;; dash-lines are VERY unefficient (loop for i from d to (w self) by d do (draw-v-grid-line self i)) (loop for i from d to (h self) by d do (draw-h-grid-line self i)) ; ) )) (defmethod om-draw-contents ((self patch-editor-view)) (let ((editor (editor (om-view-window self)))) (when (grid (object editor)) (draw-patch-grid self (grid (object editor)))) (mapcar 'om-draw-contents (get-grap-connections self)))) (defmethod window-name-from-object ((self OMPatchInternal)) (format nil "~A [~A]" (name self) "internal patch")) ;;;========================== ;;; LOCK ;;;========================== (defclass lock-view-area (om-item-view) ((editor :accessor editor :initarg :editor :initform nil) (locked-icon :accessor locked-icon :initarg :locked-icon :initform nil) (unlocked-icon :accessor unlocked-icon :initarg :unlocked-icon :initform nil) )) (defmethod om-draw-contents ((self lock-view-area)) (let ((w (min (w self) 18)) (h (min (h self) 18))) (unless (locked-icon self) (setf (locked-icon self) (om-load-picture-for-view :lock self))) (unless (unlocked-icon self) (setf (unlocked-icon self) (om-load-picture-for-view :unlock self))) (om-draw-picture (if (lock (object (editor self))) (locked-icon self) (unlocked-icon self)) :x (/ (- (w self) w) 2) :y (/ (- (h self) h) 2) :w w :h h ))) (defmethod om-view-click-handler ((self lock-view-area) position) (declare (ignore position)) (setf (lock (object (editor self))) (not (lock (object (editor self))))) (om-invalidate-view self) (om-invalidate-view (main-view (editor self)))) (defmethod add-lock-item ((editor patch-editor) view) (om-add-subviews view (om-make-graphic-object 'lock-view-area :position (omp 0 2) :size (omp 20 20) :editor editor)) ) ;;;========================== ;;; MENU ;;;========================== (defmethod om-menu-items ((self patch-editor)) (remove nil (list (main-app-menu-item) (om-make-menu "File" (append (default-file-menu-items self) (list (om-make-menu-item "Open as Text..." #'(lambda () (patch-editor-open-text-editor self)) :enabled #'(lambda () (and (is-persistant (object self)) (mypathname (object self)))))))) (om-make-menu "Edit" (append (default-edit-menu-items self) (list (om-make-menu-comp (list (om-make-menu-item "Show Lisp code" #'(lambda () (patch-editor-set-window-config self (if (equal (editor-window-config self) :lisp-code) nil :lisp-code))) :key "l" :selected #'(lambda () (equal (editor-window-config self) :lisp-code)) ) (om-make-menu-item "Show Inspector" #'(lambda () (patch-editor-set-window-config self (if (equal (editor-window-config self) :inspector) nil :inspector))) :key "i" :selected #'(lambda () (equal (editor-window-config self) :inspector)) ) (om-make-menu-item "Show Listener Output" #'(lambda () (patch-editor-set-window-config self (if (equal (editor-window-config self) :listener) nil :listener))) :key "m" :selected #'(lambda () (equal (editor-window-config self) :listener)) ) (om-make-menu-item "Show Grid" #'(lambda () (setf (grid (object self)) (if (grid (object self)) nil 50)) (om-invalidate-view (main-view self))) :key "g" :selected #'(lambda () (grid (object self))) ) (om-make-menu-item "Edit lock" #'(lambda () (setf (lock (object self)) (not (lock (object self)))) (om-invalidate-view (main-view self))) :key "e" :selected #'(lambda () (lock (object self))) )) :selection t) (om-make-menu-comp (list (om-make-menu-item "Abort Evaluation" #'(lambda () (abort-eval)) :key "A" :enabled #'(lambda () (not (edit-lock self))) ))) )) ) (om-make-menu "Boxes" (list (om-make-menu "Add box..." (add-box-menu-items (main-view self) nil)) (om-make-menu-comp (list (om-make-menu-item "Selection:" nil :enabled nil) (om-make-menu-item "Align [Shift+A]" #'(lambda () (store-current-state-for-undo self) (align-selected-boxes self)) ; :key "A" :enabled #'(lambda () (and (not (edit-lock self)) (get-selected-boxes self))) ) (om-make-menu-item "Consolidate appearance [Shift+S]" #'(lambda () (store-current-state-for-undo self) (let ((selection (append (get-selected-boxes self) (get-selected-connections self)))) (mapc 'consolidate-appearance selection) (update-inspector-for-editor self nil t))) :enabled #'(lambda () (and (not (edit-lock self)) (or (get-selected-boxes self) (get-selected-connections self)))) ) (om-make-menu-item "Init size [I]" #'(lambda () (store-current-state-for-undo self) (mapc 'initialize-size (or (get-selected-boxes self) (get-selected-connections self)))) ; :key "i" :enabled #'(lambda () (and (not (edit-lock self)) (or (get-selected-boxes self) (get-selected-connections self)))) ) (om-make-menu-item "Reinit content [Shift+I]" #'(lambda () (store-current-state-for-undo self) (mapc 'initialize-size (or (get-selected-boxes self) (get-selected-connections self)))) :enabled #'(lambda () (and (not (edit-lock self)) (or (get-selected-boxes self) (get-selected-connections self)))) ; :key "I" :key-mod nil ) (om-make-menu-item "Connect one [C]" #'(lambda () (store-current-state-for-undo self) (auto-connect-box (get-selected-boxes self) self (main-view self))) :enabled #'(lambda () (and (not (edit-lock self)) (get-selected-boxes self))) ) (om-make-menu-item "Connect sequence [Shift+C]" #'(lambda () (store-current-state-for-undo self) (auto-connect-seq (get-selected-boxes self) self (main-view self))) :enabled #'(lambda () (and (not (edit-lock self)) (get-selected-boxes self))) ) (om-make-menu-item "Create List [Shift+L]" #'(lambda () (store-current-state-for-undo self) (list-boxes self (main-view self) (get-selected-boxes self))) :enabled #'(lambda () (and (not (edit-lock self)) (get-selected-boxes self))) ) (om-make-menu-item "Set Reactive [R]" #'(lambda () (store-current-state-for-undo self) (mapc 'set-reactive-mode (or (get-selected-boxes self) (get-selected-connections self)))) :enabled #'(lambda () (and (not (edit-lock self)) (or (get-selected-boxes self) (get-selected-connections self)))) ) (om-make-menu-item "Internalize abstraction(s) [A]" #'(lambda () (store-current-state-for-undo self) (mapc 'internalize-abstraction (get-selected-boxes self))) :enabled #'(lambda () (and (not (edit-lock self)) (get-selected-boxes self))) ) (om-make-menu-item "Encapsulate selection [Shift+E]" #'(lambda () (encapsulate-patchboxes self (main-view self) (get-selected-boxes self))) :enabled #'(lambda () (and (not (edit-lock self)) (get-selected-boxes self))) ) (om-make-menu-item "Unencapsulate selection [Shift+U]" #'(lambda () (unencapsulate-patchboxes self (main-view self) (get-selected-boxes self))) :enabled #'(lambda () (and (not (edit-lock self)) (get-selected-boxes self))) ) )))) (om-make-menu "Windows" (default-windows-menu-items self)) (om-make-menu "Help" (default-help-menu-items self)) ))) (defun new-box-from-menu (name view position) (if (and view position) (progn (select-unselect-all (editor view) nil) (new-box-in-patch-editor view name position)) (set-add-item-on-patch name))) (defun add-box-menu-items (view position) (list (om-make-menu-item "Input" #'(lambda () (new-box-from-menu "in" view position ))) (om-make-menu-item "Output" #'(lambda () (new-box-from-menu "out" view position))) (om-make-menu-item "Internal Patch" #'(lambda () (new-box-from-menu "patch" view position))) (om-make-menu-item "Internal Lisp Function" #'(lambda () (new-box-from-menu "lisp" view position))) (om-make-menu-item "Internal Sequencer" #'(lambda () (new-box-from-menu "sequencer" view position))) (om-make-menu-item "External Abstraction (p)" #'(lambda () (new-box-from-menu "import" view position))) (om-make-menu-item "Comment (c)" #'(lambda () (new-box-from-menu "comment" view position))) (om-make-menu-comp (loop for pack in (elements *om-package-tree*) collect (make-package-menu pack view position))) (om-make-menu-comp #'(lambda (ed) (declare (ignore ed)) (loop for libname in (all-om-libraries t) collect (make-package-menu (find-library libname) view position)) )) )) (defmethod box-symbol ((self t)) self) ;;; will be passed to the Help menus (defmethod get-selection-for-menu ((self patch-editor)) (remove-duplicates (mapcar #'(lambda (b) (box-symbol (reference b))) (get-selected-boxes self)) )) (defmethod om-get-menu-context ((self patch-editor-view)) (let ((position (om-mouse-position self))) (list (om-make-menu-comp (list (om-make-menu-item "Add box / patch component..." nil :enabled nil))) (add-box-menu-items self position) ))) ;;;========================= ;;; EVENT HANDLERS ;;;========================= (defmethod get-selected-boxes ((self patch-editor)) (let ((boxes (boxes (object self)))) (remove-if-not 'selected boxes))) (defmethod get-selected-connections ((self patch-editor)) (let ((connections (connections (object self)))) (remove-if-not 'selected connections))) ;;; callback from the GUI (defmethod editor-close ((self patch-editor)) (call-next-method) (let ((patch (object self))) (release-reference patch self) (close-document patch) )) (defmethod om-view-doubleclick-handler ((self patch-editor-view) pos) (unless (or (om-point-in-rect-p pos 0 0 20 20) (edit-lock (editor self))) (enter-new-box self (om-add-points pos (om-make-point -8 -14))))) (defmethod om-view-click-handler ((self patch-editor-view) position) ;;; special : click on the lock-button (unless (om-shift-key-p) (select-unselect-all (editor self) nil)) (or (click-connection-handle self position) (progn (when (om-get-clipboard) (set-paste-position position self)) (if *add-item-on-patch* (new-box-in-patch-editor self (string *add-item-on-patch*) position) (mouse-selection self position)) )) ) ;;;handles the selction/drag, etc. of connections (defmethod click-connection-handle ((self patch-editor-view) pos) (let ((selected-connection (find-if #'(lambda (c) (point-in-connection pos c)) (get-grap-connections self))) (p0 pos)) (when selected-connection (setf (view selected-connection) self) (select-box (object selected-connection) (if (om-shift-key-p) (not (selected (object selected-connection))) t)) (unless (edit-lock (editor self)) (store-current-state-for-undo (editor self)) (om-init-temp-graphics-motion self pos nil :motion #'(lambda (view p) (declare (ignore view)) (drag-connection (object selected-connection) (- (om-point-x p) (om-point-x p0)) (- (om-point-y p) (om-point-y p0))) (om-invalidate-view self) (setf p0 p) ) :min-move 4) ) t) )) (defmethod box-key-action ((box t) key) nil) (defmethod editor-key-action ((editor patch-editor) key) (declare (special *general-player*)) (let* ((panel (get-editor-view-for-action editor)) (selected-boxes (get-selected-boxes editor)) (selected-connections (get-selected-connections editor)) (player-active (and (boundp '*general-player*) *general-player*))) (when panel (if (and (om-action-key-down) selected-boxes) ;; works with special keys (arrows, enter, ...) ;; 'normal' keys are caught through the menu shortcut system (loop for box in selected-boxes do (box-key-action box key)) (case key ;;; play/stop commands (#\Space (when player-active (play/stop-boxes selected-boxes))) (#\s (when player-active (stop-boxes selected-boxes))) (:om-key-delete (unless (edit-lock editor) (store-current-state-for-undo editor) (remove-selection editor))) (#\n (if selected-boxes (mapc 'set-show-name selected-boxes) (unless (edit-lock editor) (make-new-box panel)))) (#\p (unless (edit-lock editor) (make-new-abstraction-box panel))) (:om-key-left (unless (edit-lock editor) (if (om-option-key-p) (when selected-boxes (store-current-state-for-undo editor) (mapc 'optional-input-- selected-boxes)) (let ((selection (or selected-boxes selected-connections))) (store-current-state-for-undo editor :action :move :item selection) (mapc #'(lambda (f) (move-box f (if (om-shift-key-p) -10 -1) 0)) selection)) ))) (:om-key-right (unless (edit-lock editor) (if (om-option-key-p) (when selected-boxes (store-current-state-for-undo editor) (mapc 'optional-input++ selected-boxes)) (let ((selection (or selected-boxes selected-connections))) (store-current-state-for-undo editor :action :move :item selection) (mapc #'(lambda (f) (move-box f (if (om-shift-key-p) 10 1) 0)) selection)) ))) (:om-key-up (unless (edit-lock editor) (store-current-state-for-undo editor :action :move :item (or selected-boxes selected-connections)) (mapc #'(lambda (f) (move-box f 0 (if (om-shift-key-p) -10 -1))) (or selected-boxes selected-connections)) )) (:om-key-down (unless (edit-lock editor) (store-current-state-for-undo editor :action :move :item (or selected-boxes selected-connections)) (mapc #'(lambda (f) (move-box f 0 (if (om-shift-key-p) 10 1))) (or selected-boxes selected-connections)) )) (#\k (unless (edit-lock editor) (when selected-boxes (store-current-state-for-undo editor) (mapc 'keyword-input++ selected-boxes)))) (#\+ (unless (edit-lock editor) (when selected-boxes (store-current-state-for-undo editor) (mapc 'keyword-input++ selected-boxes)))) (#\K (unless (edit-lock editor) (when selected-boxes (store-current-state-for-undo editor) (mapc 'keyword-input-- selected-boxes)))) (#\- (unless (edit-lock editor) (when selected-boxes (store-current-state-for-undo editor) (mapc 'keyword-input-- selected-boxes)))) (#\> (unless (edit-lock editor) (when selected-boxes (store-current-state-for-undo editor) (mapc 'optional-input++ selected-boxes)))) (#\< (unless (edit-lock editor) (when selected-boxes (store-current-state-for-undo editor) (mapc 'optional-input-- selected-boxes)))) (#\b (when selected-boxes (store-current-state-for-undo editor) (mapc 'switch-lock-mode selected-boxes))) (#\1 (unless (or (edit-lock editor) (get-pref-value :general :auto-ev-once-mode)) (when selected-boxes (store-current-state-for-undo editor) (mapc 'switch-evonce-mode selected-boxes)))) (#\l (unless (edit-lock editor) (when selected-boxes (store-current-state-for-undo editor) (mapc 'switch-lambda-mode selected-boxes)))) (#\m (mapc 'change-display selected-boxes)) ;;; Box editing ;;; => menu commands ? (#\A (unless (edit-lock editor) (store-current-state-for-undo editor) (align-selected-boxes editor))) (#\S (unless (edit-lock editor) (store-current-state-for-undo editor) (let ((selection (append selected-boxes selected-connections))) (mapc 'consolidate-appearance selection) (update-inspector-for-editor editor nil t)))) (#\c (unless (edit-lock editor) (store-current-state-for-undo editor) (if selected-boxes (auto-connect-box selected-boxes editor panel) (make-new-comment panel)))) (#\C (unless (edit-lock editor) (store-current-state-for-undo editor) (auto-connect-seq selected-boxes editor panel))) (#\r (unless (edit-lock editor) (store-current-state-for-undo editor) (mapc 'set-reactive-mode (or selected-boxes selected-connections)))) (#\i (unless (edit-lock editor) (store-current-state-for-undo editor) (mapc 'initialize-size (or selected-boxes selected-connections)))) (#\I (mapc 'initialize-box-value selected-boxes)) (#\r (unless (edit-lock editor) (store-current-state-for-undo editor) (mapc 'set-reactive-mode (or selected-boxes selected-connections)))) ;;; abstractions (#\a (unless (edit-lock editor) (when selected-boxes (store-current-state-for-undo editor) (mapc 'internalize-abstraction selected-boxes)))) (#\E (unless (edit-lock editor) (encapsulate-patchboxes editor panel selected-boxes))) (#\U (unless (edit-lock editor) (unencapsulate-patchboxes editor panel selected-boxes))) (#\L (unless (edit-lock editor) (store-current-state-for-undo editor) (list-boxes editor panel selected-boxes))) (#\v (eval-editor-boxes editor selected-boxes)) (#\w (om-debug)) (#\h (funcall (help-command editor))) (#\d (when selected-boxes (mapcar #'print-help-for-box selected-boxes))) (otherwise nil)) )))) ;; redefine to do something :) (defun om-debug () (om-beep)) ;(defun om-debug () (format *standard-output* "~%===================================") (pprint *open-documents*)) (defmethod editor-help-list ((self patch-editor)) '(("N" "If no box selected: create a new box (enter name in text-field)") ("N" "If selected box(es): show/hide name") ("C" "Create a new comment (enter name in text-field)") ("P" "Create a new abstraction box (enter name/pathname of an existing patch)") ("V" "Evaluate selected box(es)") ("B" "Lock/unlock selected box(es)") ("L" "Set/remove lambda mode for selected box(es)") ("1" "Set/remove ev-once mode for selected box(es)") ("R" "Set/remove reactive mode for selected box(es)") ("M" "Change display mode on selected box(es)") ("SHIFT + A" "Align selected box(es)") ("I" "Reinitialize selected box(es) size") ("SHIFT + S" "Consolidate selected box(es) appearance") ("SHIFT + I" "Reinitialize selected box(es) value") ("SHIFT + E" "Encapsulate selected boxes in an internal patch") ("SHIFT + U" "Unencapsulate internal patch") ("A" "Internalize external patch") ("C" "Connect selected boxes (horizontal)") ("SHIFT + C" "Connect selected boxes (vertical)") ("SHIFT + L" "Create a LIST box connected to the selected box(es)") ("Space" "Play/stop selected (playable) box(es)") ("H" "Print this help") )) ;;;============================= ;;; BASIC ACTIONS ;;;============================= (defmethod select-unselect-all ((self patch-editor) val) (mapcar #'(lambda (x) (select-box x val)) (append (boxes (object self)) (connections (object self)))) (om-invalidate-view (main-view self))) (defmethod remove-boxes ((self patch-editor) boxes) (mapc #'(lambda (box) (mapcar #'(lambda (c) (omng-remove-element self c)) (get-box-connections box)) (omng-remove-element self box) (delete-box-frame (frame box)) ;;; removes the view (omng-delete box) ;;; deals with contents/references ) boxes)) (defmethod remove-selection ((self patch-editor)) (let ((selectedboxes (get-selected-boxes self)) (selectedconnections (get-selected-connections self)) (view (main-view self))) (when (or selectedboxes selectedconnections) (remove-boxes self selectedboxes) (mapc #'(lambda (c) (omng-remove-element self c)) selectedconnections) (report-modifications self) (when view (om-invalidate-view view))) )) (defmethod align-selected-boxes ((editor patch-editor)) (let ((selected-boxes (get-selected-boxes editor))) (if selected-boxes (progn (store-current-state-for-undo editor) (mapc 'align-box selected-boxes)) (om-beep)) )) (defmethod list-boxes ((editor patch-editor) view boxes) (let ((connectable-boxes (remove-if #'(lambda (box) (< (length (outputs box)) 1)) boxes))) (when connectable-boxes (let* ((pos (loop for b in connectable-boxes sum (box-x b) into sumx maximize (+ (box-y b) (box-h b)) into maxy finally (return (om-make-point (floor sumx (length connectable-boxes)) (+ maxy 28))))) (box (omNG-make-new-boxcall (fdefinition 'list) pos (make-list (length connectable-boxes))))) (setf (name box) "list") (store-current-state-for-undo editor) (add-box-in-patch-editor box view) (auto-connect-box (cons box connectable-boxes) editor view) (align-selected-boxes editor) )))) ;;;============================= ;;; MAKE BOXES ;;;============================= ;;; called from keyboard actions: do it at the last click pos (defmethod make-new-box ((self patch-editor-view)) (let ((mp (om-mouse-position self))) (enter-new-box self (if (om-point-in-rect-p mp 0 0 (w self) (h self)) mp (om-make-point (round (w self) 2) (round (h self) 2)))) )) (defmethod make-new-abstraction-box ((self patch-editor-view)) (let ((mp (om-mouse-position self))) (enter-new-box self (if (om-point-in-rect-p mp 0 0 (w self) (h self)) mp (om-make-point (round (w self) 2) (round (h self) 2))) :patch) )) (defmethod make-new-comment ((self patch-editor-view)) (let ((mp (om-mouse-position self))) (enter-new-comment self (if (om-point-in-rect-p mp 0 0 (w self) (h self)) mp (om-make-point (round (w self) 2) (round (h self) 2)))) )) (defmethod make-new-comment ((self t)) nil) ;;;========================== ;;; SELECTION ;;;========================== (defmethod get-boxframes ((self patch-editor-view) &key only-selected) (let ((frames (remove-if-not #'(lambda (item) (subtypep (type-of item) 'omframe)) (om-subviews self)))) (if only-selected (remove-if-not 'selected frames :key 'object) frames))) (defmethod mouse-selection ((self patch-editor-view) pos) (let ((p0 pos)) (om-init-temp-graphics-motion self pos (om-make-graphic-object 'selection-rectangle :position pos :size (om-make-point 4 4)) :min-move 4 :release #'(lambda (view position) (select-items-in-rect view (om-point-x p0) (om-point-y p0) (om-point-x position) (om-point-y position))) ))) (defmethod select-items-in-rect ((self patch-editor-view) x1 y1 x2 y2) (dolist (item (get-boxframes self)) (when (rect-intersection x1 y1 x2 y2 (x item) (y item) (+ (x item) (w item)) (+ (y item) (h item))) (select-box (object item) t) ))) ;;;============================= ;;; DEF MENU COMMANDS ;;;============================= ;;; called from menu (defmethod clear-command ((self patch-editor)) #'(lambda () (remove-selection self))) (defmethod select-all-command ((self patch-editor)) #'(lambda () (let ((focus (or (om-get-subview-with-focus (window self)) (main-view self)))) (when focus ;;; can be the main view or a text-input field for instance (select-all-command-for-view self focus) )))) (defmethod select-all-command-for-view ((self patch-editor) (view t)) (select-unselect-all self t)) ;;;=========================================== ;;; COPY / CUT / PASTE ;;;=========================================== (defmethod copy-command-for-view ((editor patch-editor) (view t)) (let* ((boxes (get-selected-boxes editor)) (connections (save-connections-from-boxes boxes))) (set-paste-position nil) (set-om-clipboard (list (mapcar 'om-copy boxes) connections)))) (defmethod cut-command-for-view ((editor patch-editor) (view t)) (copy-command-for-view editor view) (store-current-state-for-undo editor) (remove-selection editor)) (defmethod paste-command-for-view ((editor patch-editor) (view t)) (om-beep-msg "Can't paste on ~A" view)) (defmethod paste-command-for-view ((editor patch-editor) (view patch-editor-view)) (unless (edit-lock editor) (let* ((boxes (car (get-om-clipboard))) (connections (cadr (get-om-clipboard))) (paste-pos (get-paste-position view)) (ref-pos)) (select-unselect-all editor nil) (when paste-pos (setq ref-pos (loop for bb in boxes minimize (omg-x view (box-x bb)) into xmin minimize (omg-y view (box-y bb)) into ymin finally (return (om-make-point xmin ymin)))) (set-paste-position nil)) (store-current-state-for-undo editor) (loop for b in boxes do (let* ((box-pos (omg-position view (omp (box-x b) (box-y b)))) (box-size (omg-size view (om-borne-point (omp (box-w b) (box-h b)) (minimum-size b) (maximum-size b) ))) (graphic-pos (if ref-pos (om-add-points paste-pos (om-subtract-points box-pos ref-pos)) (om-borne-point (om-add-points box-pos (om-make-point 40 10)) (omp 0 0) (om-subtract-points (om-view-size view) box-size)) ))) (omng-move b (omng-position view graphic-pos)) (when (omNG-add-element editor b) (let ((frame (make-frame-from-callobj b))) (om-set-view-position frame graphic-pos) (om-add-subviews view frame) (update-frame-size-for-view frame view) (select-box b t) )))) ;;; connections (loop for c in (restore-connections-to-boxes connections boxes) do (omng-add-element editor c) (add-connection-in-view view c)) (mapc 'after-copy-action boxes) (om-invalidate-view view) (set-om-clipboard (list (mapcar 'om-copy boxes) connections)) ))) (defmethod after-copy-action ((self t)) nil) (defmethod copy-command-for-view ((editor patch-editor) (view om-editable-text)) (om-copy-command view)) (defmethod cut-command-for-view ((editor patch-editor) (view om-editable-text)) (if (edit-lock editor) (om-beep) (om-cut-command view))) (defmethod paste-command-for-view ((editor patch-editor) (view om-editable-text)) (if (edit-lock editor) (om-beep) (om-paste-command view))) (defmethod select-all-command-for-view ((editor patch-editor) (view om-editable-text)) (om-select-all-command view)) ;;; called from menu (defmethod copy-command ((self patch-editor)) #'(lambda () (let ((focus (or (om-get-subview-with-focus (window self)) (main-view self)))) (when focus ;;; can be the main view or a text-input field for instance (copy-command-for-view self focus) )))) ;;; called from menu (defmethod cut-command ((self patch-editor)) #'(lambda () (let ((focus (or (om-get-subview-with-focus (window self)) (main-view self)))) (when focus ;;; can be the main view or a text-input field for instance (cut-command-for-view self focus) )))) (defmethod paste-command ((self patch-editor)) #'(lambda () (let ((focus (or (om-get-subview-with-focus (window self)) (main-view self)))) (when focus ;;; can be the main view or a text-input field for instance (paste-command-for-view self focus))))) (defmethod report-modifications ((self patch-editor)) (call-next-method) (patch-editor-set-lisp-code self)) ;;;============================= ;;; DRAG BOXES ;;;============================= (defmethod container-frames-locked ((self t)) t) (defmethod container-frames-locked ((self patch-editor-view)) (edit-lock (editor self))) (defmethod om-drag-start ((self OMBoxFrame) pos) (declare (special *resize-handler* *connection-handler*)) (unless (or *resize-handler* *connection-handler* (active-area-at-pos self pos) (om-action-key-down) (container-frames-locked (om-view-container self))) (let ((pv (om-view-container self))) (om-set-focus pv) ;; will close the temporary text-edit field if any (setf (dragged-views pv) (get-boxframes pv :only-selected t)) t))) (defun get-frames-rect (frames-list) (when frames-list (list (reduce 'min (mapcar 'x frames-list)) (reduce 'min (mapcar 'y frames-list)) (reduce 'max (mapcar 'x+w frames-list)) (reduce 'max (mapcar 'y+h frames-list)) ))) (defmethod om-drag-area ((self OMBoxFrame)) (let ((pv (om-view-container self))) (if (dragged-views pv) (values-list (get-frames-rect (dragged-views pv))) (call-next-method)))) (defmethod om-draw-contents-for-drag ((self OMBoxFrame)) (let* ((pv (om-view-container self)) (patch (object (editor pv))) (boxframes (dragged-views pv)) (rect (get-frames-rect boxframes))) (om-with-alpha 0.6 (loop for v in boxframes do (om-with-translation (- (x v) (car rect)) (- (y v) (cadr rect)) (boxframe-draw-contents v (object v)))) (loop for c in (connections patch) when (and (find (box (from c)) boxframes :key 'object) (find (box (to c)) boxframes :key 'object)) do (let ((gc (graphic-connection c))) (om-with-translation (- (x gc) (car rect)) (- (y gc) (cadr rect)) (om-draw-contents gc))) ) ))) (defmethod allowed-move (box (editor patch-editor)) (allowed-element (object editor) box)) (defmethod om-drag-receive ((self patch-editor-view) (dragged-view OMBoxFrame) position &optional (effect nil)) (unless (om-points-equal-p (om-view-position dragged-view) position) (let* ((init-patch (container (object dragged-view))) (patchview (om-view-container dragged-view)) (editor (editor self)) (target-patch (object editor)) (initpos (om-view-position dragged-view)) (newpositions (mapcar #'(lambda (view) (om-add-points position (om-subtract-points (om-view-position view) initpos))) (dragged-views patchview)))) ;;; conditions for cancelled dag-and-drop: (unless (or ;;; editor locked (edit-lock editor) ;;; wrong final position (find-if #'(lambda (p) (or (< (om-point-x p) 0) (< (om-point-y p) 0))) newpositions) ;;; move patch in itself or other not-allowed move (and (not (equal effect :copy)) (not (equal init-patch target-patch)) (member nil (loop for dview in (dragged-views patchview) collect (allowed-move (object dview) editor))))) (let ((connections (save-connections-from-boxes (mapcar 'object (dragged-views patchview)))) (newboxes nil)) (store-current-state-for-undo editor) (loop for dview in (dragged-views patchview) for pos in newpositions do (let* ((box (object dview)) ;;; in case of sequencer container (box-beg-position (omng-position self pos))) (if (equal effect :copy) ;;; COPY (let ((newbox (om-copy box))) (pushr newbox newboxes) (when (and newbox (omNG-add-element (editor self) newbox)) (omng-move newbox box-beg-position) (let ((frame (make-frame-from-callobj newbox))) ;;; set the frame at the graphic pos (om-set-view-position frame pos) ;;; set the frame at the graphic size (om-set-view-size frame (om-view-size dview)) (om-add-subviews self frame) (contextual-update newbox target-patch) ;;; update connections (update-connections newbox) (select-box newbox t) (select-box box nil) (om-invalidate-view frame) (om-invalidate-view dview) t ))) ;;; NOT COPY = MOVE (if (equal init-patch target-patch) ;;; IN THE SAME PATCH (progn (omng-move box box-beg-position) (om-set-view-position dview pos) (update-connections box) (redraw-connections dview) (om-invalidate-view self) t) (progn ;;; IN ANOTHER PATCH (omng-remove-element init-patch box) (report-modifications (editor init-patch)) (mapcar #'(lambda (c) (omng-remove-element init-patch c)) (get-box-connections box)) (om-remove-subviews patchview dview) (pushr box newboxes) (when (omNG-add-element editor box) (omng-move box box-beg-position) ;;; set the frame at the graphic pos & size (om-set-view-position dview pos) (om-set-view-size dview (om-view-size dview)) (om-add-subviews self dview) (contextual-update box target-patch) (update-connections box) (om-invalidate-view dview) ) t) )))) (setf (dragged-views self) nil) (when newboxes ;;; the boxes have been copied: restore the connections ! (mapcar #'(lambda (c) (omng-add-element target-patch c) (add-connection-in-view self c) (update-points c)) (restore-connections-to-boxes connections newboxes)) (mapcar 'redraw-connections (get-boxframes self :only-selected t)) (mapc 'after-copy-action newboxes) (om-invalidate-view (editor-view init-patch)) ) t)) ))) ;;; drag&drop on oneself = slight move (defmethod om-drag-receive ((self OMBoxFrame) (dragged-view OMBoxFrame) position &optional (effect nil)) (let ((patchview (om-view-container self))) (when (find self (dragged-views (om-view-container dragged-view))) (om-drag-receive patchview dragged-view position effect)))) (defmethod omNG-make-new-box-from-file (type file pos) nil) ;;; drag&drop from the computer... (defmethod om-import-files-in-app ((self patch-editor-view) file-list position) (let* ((file (pathname (car file-list))) (objtype (extension-to-doctype (pathname-type file))) (newbox (if (member objtype *om-doctypes*) (let ((obj (load-doc-from-file file objtype))) (when obj (omNG-make-new-boxcall obj position))) (let ((other-supported-type (find objtype *doctypes* :key 'car))) (if other-supported-type (omNG-make-new-box-from-file (car other-supported-type) file position) (om-beep)))))) (when newbox (store-current-state-for-undo (editor self)) (add-box-in-patch-editor newbox self) ))) ;;;============================= ;;; TEXT COMPLETION ;;;============================= (defparameter *om-box-name-completion* t) (defparameter *all-om-pack-symbols* nil) (defun set-om-pack-symbols () (setf *all-om-pack-symbols* (sort (mapcar 'string-downcase (append (get-all-symbol-names *om-package-tree*) (get-all-symbol-names *om-libs-root-package*))) 'string<))) (defun box-name-completion (string) (if (and *om-box-name-completion* (>= (length string) 1)) (let ((all-str (append (or *all-om-pack-symbols* (set-om-pack-symbols)) '("in" "out" "patch" "sequencer" "lisp" "comment")))) (remove-if #'(lambda (str) (not (equal 0 (search string str :test 'string-equal)))) all-str)) ;:destroy )) (defun list-search-path-contents (path) (and path (om-directory path :files t :directories nil :type (mapcar #'doctype-to-extension *om-doctypes*) :recursive (get-pref-value :files :search-path-rec)))) (defun patch-name-completion (patch string) (if (and *om-box-name-completion* (>= (length string) 1)) (let* ((searchpath-strings (mapcar 'pathname-name (append (list-search-path-contents (get-pref-value :files :search-path)) (list-search-path-contents (get-pref-value :files :search-path-2)) (list-search-path-contents (get-pref-value :files :search-path-3)) (list-search-path-contents (get-pref-value :files :search-path-4))))) (localpath-strings (when (mypathname patch) (let* ((currentpathbase (namestring (om-make-pathname :directory string))) (localfolder (om-make-pathname :directory (merge-pathnames string (mypathname patch)))) (filecandidates (mapcar 'pathname-name (om-directory localfolder :files t :directories nil :type (mapcar #'doctype-to-extension *om-doctypes*) :recursive nil)))) (loop for file in filecandidates collect (string+ currentpathbase file)))))) (remove-if #'(lambda (str) (not (equal 0 (search string str :test 'string-equal)))) (append searchpath-strings localpath-strings)) ) )) ;(search "om-" "OM-SCALE" :test 'string-equal) ;(defmethod activate-completion ((self text-input-item)) ;;; mode 1 ;(when *om-box-name-completion* (om-set-text-completion self 'box-name-completion)) ;;; mode 2 ; (setf *om-box-name-completion* t) ; (om-complete-text self)) ;;;============================= ;;; NEW BOX ;;;============================= (defclass text-input-item (om-editable-text) ()) ;(defclass text-input-item (om-custom-edit-text) ()) (defmethod get-new-box-from-type ((type t) position container) nil) ;(defmethod om-view-key-handler ((self text-input-item) key) ;(if (capi:text-input-pane-text self) (capi:text-input-pane-complete-text self) nil) ;) (defmethod enter-new-box ((self patch-editor-view) position &optional type) ;;; mode 2 ;(setf *om-box-name-completion* nil) (let* ((patch (object (editor self))) (prompt (if (equal type :patch) "enter external patch name (or pathname)" "enter box name")) (completion-fun (if (equal type :patch) #'(lambda (string) (unless (string-equal string prompt) (patch-name-completion patch string))) 'box-name-completion)) (textinput (om-make-di 'text-input-item :text prompt ;:focus t :fg-color (om-def-color :gray) :di-action #'(lambda (item) (let ((text (om-dialog-item-text item))) (om-end-text-edit item) (om-remove-subviews self item) (unless (string-equal text prompt) (if (equal type :patch) (new-abstraction-box-in-patch-editor self text position) (new-box-in-patch-editor self text position) )) (om-set-focus self))) :begin-edit-action #'(lambda (item) (om-set-fg-color item (om-def-color :dark-gray)) ) :edit-action #'(lambda (item) (let ((textsize (length (om-dialog-item-text item)))) (om-set-fg-color item (om-def-color :dark-gray)) (om-set-view-size item (om-make-point (list :character (+ 2 textsize)) 20)) )) :completion completion-fun :font (om-def-font :normal) :size (om-make-point 100 30) :position position :border t ;ouvre une nouvelle vue de clompletion mais ne la ferme pas... ;:gesture-callbacks (list ; (cons ; #\tab ; #'(lambda (tip) ; (if (capi:text-input-pane-complete-text tip) t :destroy) ; )) ; (cons ; #\space ; #'(lambda (tip) ; (if (capi:text-input-pane-in-place-complete tip) nil :destroy) ; ; ) ; ) ; ) ))) (om-add-subviews self textinput) (om-set-text-focus textinput t) t)) (defmethod special-box-p (name) nil) (defvar *known-packages* nil) (defun declare-known-package (p) (pushnew p *known-packages*)) (defun search-known-symbol (str) (let* ((strUC (string-upcase str)) (package (when (find #\: strUC) (string-until-char strUC ":")))) (if (> (length package) 0) ;; package is not NIL or "" (let ((sym-name (subseq strUC (1+ (position #\: strUC :from-end t))))) (find-symbol sym-name (intern-k package))) (let ((sym nil)) (loop for p in (reverse *known-packages*) while (not sym) do (let ((s (find-symbol strUC p))) (when (or (fboundp s) (find-class s nil) (special-box-p s)) (setf sym s)))) sym) ))) ;(string-until-char "CR::CS-EVT" ":") ;(position #\: "CR:CS-EVT" :from-end t) ; (search-known-symbol "iae") ; (find-symbol "CR::CS-EVT" :cr) (defun export-symbol-from-om (symb) (let ((p (symbol-package symb))) (export symb p) (declare-known-package p))) (defun decode-input-arguments (text) (om-read-list-from-string text)) (defmethod new-box-in-patch-editor ((self patch-editor-view) str position) (om-with-error-handle (when (and (stringp str) (> (length str) 0)) (multiple-value-bind (first-item other-items) (string-until-char (delete-spaces str) " ") (let* ((*package* (find-package :om)) (read-sym (and (not (equal #\( (elt first-item 0))) (search-known-symbol first-item))) (pos (omng-position self position)) (newbox nil)) (if read-sym ;;; the symbol is known (let ((args (decode-input-arguments (delete-spaces other-items)))) (setf newbox (cond ((special-box-p read-sym) (omNG-make-special-box read-sym pos args)) ((om-special-lisp-form-p read-sym) (om-beep-msg (string+ "Special Lisp form '" str "' can not be created as a box!"))) ((macro-function read-sym) (om-beep-msg (string+ "macro functions not supported: " str ""))) ((equal read-sym t) (omNG-make-new-boxcall 'value pos T)) ((fboundp read-sym) ;;; FUN BOX (Lisp or OM) (let ((box (omNG-make-new-boxcall (fdefinition read-sym) pos args))) (setf (name box) (string-downcase read-sym)) ;;; sometimes the "real name" is not the same.. (e.g. "list") box)) ((and (find-class read-sym nil) ;;; CLASS BOX ;(subtypep (class-of (find-class name-sym nil)) 'OMClass) ; why not standard-classes... ? ) (if (or (om-shift-key-p) (string-equal "slots" (format nil "~A" (car args)))) (omNG-make-new-boxcall 'slots pos (find-class read-sym)) (let ((box (omNG-make-new-boxcall (find-class read-sym) pos other-items))) (if (and box other-items) (setf (show-name box) t)) box))) (t nil))) ) ;;; this is not a 'known' symbol.. (but there are more options..) (let ((read-2 (read-from-string str nil))) (if (or (listp read-2) (numberp read-2) (stringp read-2) (quoted-form-p read-2) (characterp read-2) (and (symbolp read-2) (string-equal (package-name (symbol-package read-2)) "KEYWORD"))) ;;; => make a value box (progn (when (quoted-form-p read-2) (setf read-2 (eval read-2))) (setf newbox (omNG-make-new-boxcall 'value pos read-2))) ;;; unintern the symbol (when (symbolp read-2) (unintern read-2) )) ) ) (if newbox (progn (store-current-state-for-undo (editor self)) (add-box-in-patch-editor newbox self)) (om-print (format nil "Could not create a box from '~A'" first-item) "PATCH") ) ) )))) (defmethod new-abstraction-box-in-patch-editor ((self patch-editor-view) str position) (let* ((patch (find-persistant-container (object (editor self)))) (new-box (omng-make-abstraction-box str position patch))) (when new-box (store-current-state-for-undo (editor self)) (add-box-in-patch-editor new-box self)))) (defmethod special-box-p ((name (eql 'import))) t) (defmethod omNG-make-special-box ((reference (eql 'import)) pos &optional init-args) (let ((file (if init-args (string (car (list! init-args))) (om-choose-file-dialog :types (doctype-info :om))))) (if file (omng-make-abstraction-box (namestring file) pos) (om-beep-msg "Abort external import")))) ;;; refpatch allows typing the file path relative to the cirrebt patch ;;; this is available from the "p" shortcut ;;; handle/warn on possible duplicates (defmethod omng-make-abstraction-box (str position &optional in-patch) (let ((abs-types (mapcar #'doctype-to-extension *om-doctypes*)) (doc-path str)) (when (and in-patch (mypathname in-patch)) (let* ((local-restored-path (merge-pathnames str (om-make-pathname :directory (mypathname in-patch)))) (local-matches (remove nil (loop for type in abs-types collect (probe-file (merge-pathnames local-restored-path (make-pathname :type type))))))) (setq doc-path (car local-matches)) (when (> (length local-matches) 1) (om-beep-msg "Warning: there's more than 1 document named ~s in ~s" (pathname-name local-restored-path) (om-make-pathname :directory local-restored-path))) )) (unless (and doc-path (probe-file doc-path)) ;;; try with the search folder (let ((search-matches (remove nil (loop for type in abs-types collect (check-path-using-search-path (merge-pathnames str (make-pathname :type type))))))) (when (> (length search-matches) 1) (om-beep-msg "Warning: there's more than 1 document named ~s in your search-path folder" str)) ;(print search-matches) (setf doc-path (car search-matches)))) (if (and doc-path (valid-file-pathname-p doc-path)) (let ((obj (load-doc-from-file doc-path (extension-to-doctype (pathname-type doc-path))))) (when obj (omNG-make-new-boxcall obj position) )) (om-beep-msg "Warning: no file named ~s in your search-path folder" (pathname-name str))) )) ;;;============================================================================ ;;; SIDE PANEL ;;;============================================================================ ;;;====================================== ;;; LISP CODE ;;;====================================== (defun format-lisp-code-string (code margin) (concatenate 'string (string #\Newline) (write-to-string code :escape t :pretty t :right-margin margin :miser-width margin))) (defun make-lisp-code-pane (editor) (let ((lisp-pane (om-make-di 'om-multi-text :text (format-lisp-code-string (get-patch-lambda-expression (object editor)) 60) :font (om-def-font :mono) :size (omp nil nil) ))) (set-g-component editor :lisp-code lisp-pane) (om-make-layout 'om-column-layout :ratios '(nil 1 nil) :delta 10 :subviews (list (om-make-di 'om-multi-text :size (om-make-point nil 54) :text "This is the Lisp code corresponding to the selected box evaluation, or to the whole patch evaluated at its output box(es):" :fg-color (om-def-color :dark-gray) :font (om-def-font :gui)) ;; main pane ;; om-simple-layout allows setting a background color (om-make-layout 'om-simple-layout :bg-color (om-def-color :white) :subviews (list lisp-pane)) (om-make-di 'om-button :text "Copy Lisp code" :size (omp nil #+cocoa 32 #-cocoa 24) :font (om-def-font :gui) :di-action #'(lambda (b) (declare (ignore b)) (om-copy-command lisp-pane) (om-print "Lisp code copied to clipboard"))) )) )) (defmethod get-box-lisp-code ((self OMBox)) (let ((code nil)) (push-let-context) (setf code (gen-code self)) (setf code (if (output-current-let-context) `(let ,(output-current-let-context) ,code) code)) (pop-let-context) code)) (defmethod patch-editor-set-lisp-code ((self patch-editor)) (when (and (equal (editor-window-config self) :lisp-code) (get-g-component self :lisp-code)) ;; just in case.. (let* ((textpane (get-g-component self :lisp-code)) (w (om-width textpane)) (wem (om-string-size "m" (om-get-font textpane)))) (om-set-dialog-item-text (get-g-component self :lisp-code) (format-lisp-code-string (if (= (length (get-selected-boxes self)) 1) ;;; code for 1 box (get-box-lisp-code (car (get-selected-boxes self))) ;;; code for patch (get-patch-lambda-expression (object self))) (round w wem))) ))) ;;;====================================== ;;; LISTENER ;;;====================================== (defun make-listener-pane (editor) (let ((listener-pane (om-lisp::om-make-listener-output-pane (get-pref-value :general :listener-font)))) (set-g-component editor :listener listener-pane) (om-make-layout 'om-column-layout :ratios '(1 nil) :delta 0 :subviews (list ;; main pane listener-pane (om-make-layout 'om-row-layout :subviews (list nil (om-make-di 'om-button :text "x" :size #+cocoa (omp 40 32) #-cocoa (omp 24 24) :font (om-def-font :gui) :di-action #'(lambda (b) (declare (ignore b)) (om-lisp::om-clear-listener-output-pane listener-pane) )))) )) )) (defun prompt-on-patch-listener (editor message) (when (get-g-component editor :listener) (om-lisp::om-prompt-on-echo-area (get-g-component editor :listener) message))) (defun prompt-on-all-patch-listeners (message) (loop for win in (om-get-all-windows 'patch-editor-window) do (prompt-on-patch-listener (editor win) message))) (defmethod copy-command-for-view ((editor patch-editor) (view om-lisp::om-listener-pane)) (om-lisp::om-copy-command view)) (defmethod cut-command-for-view ((editor patch-editor) (view om-lisp::om-listener-pane)) (om-lisp::om-cut-command view)) (defmethod paste-command-for-view ((editor patch-editor) (view om-lisp::om-listener-pane)) (om-lisp::om-paste-command view)) (defmethod select-all-command-for-view ((self patch-editor) (view om-lisp::om-listener-pane)) (om-lisp::om-select-all-command view)) ;;;====================================== ;;; INSPECTOR ;;;====================================== (defclass inspector-view (om-view) ((object :initarg :object :initform nil :accessor object))) (defmethod make-inspector-pane ((editor patch-editor)) (let ((inspector-pane (om-make-view 'inspector-view :size (omp nil nil) :direct-draw nil))) (set-g-component editor :inspector inspector-pane) inspector-pane)) (defmethod object-name-in-inspector ((self OMObject)) (string-upcase (name self))) (defmethod object-name-in-inspector ((self t)) "-") (defmethod get-documentation ((self t)) "...") (defmethod get-documentation ((self OMFunBoxCall)) (function-documentation (reference self))) (defmethod get-documentation ((self OMBoxEditCall)) (class-documentation (reference self))) (defmethod get-documentation ((self OMPatchComponentBox)) (class-documentation (class-of (reference self)))) ;;; redefined for connections (defmethod get-update-frame ((self t)) nil) (defmethod print-help-for-box ((box t)) nil) (defmethod print-help-for-box ((box omfunboxcall)) (om-print-format "~%----------------------------------------------------~%~A~%~A~%----------------------------------------------------~%" (list (string-upcase (name box)) (or (get-documentation box) "(no documentation)")))) (defmethod print-help-for-box ((box omboxeditcall)) (om-print-format "~%----------------------------------------------------~%~A~%~A~%----------------------------------------------------~%" (list (string-upcase (reference box)) (or (get-documentation box) "(no documentation)")))) (defmethod default-editor-help-text ((self patch-editor)) "This is a patch editor window. Double-click or type 'N' to enter a new box by its name. Use the down-arrow key to pop-up auto-completed names after typing the first characters. The function and class reference accessible from the \"Help\" menu, or the \"Class/Function Library\" tab in the Session Winows (CMD/Ctrl+SHIFT+W) can provide you a list of available predefined functions. ") (defmethod set-inspector-contents ((self inspector-view) object) (unless nil ;; (equal (object self) object) (setf (object self) object) (om-remove-all-subviews self) (let* ((def-w 260) (text-font (om-def-font :gui)) (title-font (om-def-font :gui-b)) (inspector-layout (if object (om-make-layout 'om-column-layout :subviews (append (cons (om-make-di 'om-simple-text :size (om-make-point def-w 20) :fg-color (om-def-color :dark-gray) :text (object-name-in-inspector object) :focus t ;; prevents focus on other items :) :font title-font) (list (om-make-layout 'om-grid-layout :delta '(10 2) :align '(:left :center) :subviews (if (get-properties-list object) ;;; ok (loop for category in (get-properties-list object) when (cdr category) append (append (list (om-make-di 'om-simple-text :size (om-make-point 20 20) :text "" :focus t) (om-make-di 'om-simple-text :text (car category) :font title-font :fg-color (om-def-color :dark-gray) :size (om-make-point (+ 10 (om-string-size (car category) title-font)) 20) )) (loop for prop in (cdr category) append (list (om-make-di 'om-simple-text :text (string (nth 1 prop)) :font text-font :size (omp 94 16)) (make-prop-item (nth 2 prop) (nth 0 prop) object :default (nth 4 prop) :update (get-update-frame object)) )) (list (om-make-di 'om-simple-text :size (om-make-point 20 6) :text "" :focus t) (om-make-di 'om-simple-text :size (om-make-point 20 6) :text "" :focus t)) )) ;;; object has no properties (unlikely) (list (om-make-di 'om-simple-text :size (om-make-point 100 20) :text "[no properties]" :font text-font) nil)) ))) (when (get-documentation object) (list :separator (let* ((doc (get-documentation object)) (line-h (cadr (multiple-value-list (om-string-size "ABC" text-font)))) (wrap-text (om-string-wrap doc (- def-w 10) text-font)) (cut-text (if (> (length wrap-text) 10) (append (first-n wrap-text 9) '("...")) wrap-text)) (n-lines (length cut-text))) (om-make-di 'om-multi-text :size #+windows (omp nil (* line-h (1+ n-lines))) #-windows (omp nil nil) :text #+windows cut-text #-windows (format nil "~%~A~%~%" doc) ;:text (format nil "~%~A~%~%" doc) :fg-color (om-def-color :dark-gray) :font text-font) ))) )) ;;; else: no object (om-make-layout 'om-column-layout :align :bottom :subviews (list (let* ((doc (default-editor-help-text (editor self))) (line-h (cadr (multiple-value-list (om-string-size "ABC" text-font)))) (n-lines (length (om-string-wrap doc def-w text-font)))) (om-make-di 'om-multi-text :size (om-make-point def-w (* line-h (+ 2 n-lines))) :text doc :fg-color (om-def-color :dark-gray) :font text-font) ))) ))) (om-add-subviews self inspector-layout)) (when (editor self) (om-update-layout (window (editor self)))) )) ;;; !! object and view can be lists !! (defmethod set-inspector-contents ((self inspector-view) (object cons)) (let ((virtual-obj (make-instance 'virtual-object-selection :objects object))) (set-inspector-contents self virtual-obj) )) ;;; updates the inspector or the lisp code panel depending on the current selection (defmethod update-inspector-for-editor ((self patch-editor) &optional obj (force-update nil)) (let ((obj-to-inspect (or obj (let ((selection (append (get-selected-boxes self) (get-selected-connections self)))) (if (= 1 (length selection)) (car selection) selection))))) (cond ((get-g-component self :inspector) (when (or obj ;;; explicit request for this object force-update (not (equal (object (get-g-component self :inspector)) obj-to-inspect))) (set-inspector-contents (get-g-component self :inspector) obj-to-inspect) t) ) ;;; better than testing everywhere, just call it from here :) ((get-g-component self :lisp-code) (patch-editor-set-lisp-code self)) (t nil)) )) ;;; force a specific object (defun update-inspector-for-object (obj) (let ((ed (editor (get-update-frame obj)))) (when ed (update-inspector-for-editor ed obj)))) ;;; when the object is deleted (defun close-inspector-for-box (box) (let ((ed (editor (get-update-frame box)))) (when ed (update-inspector-for-editor ed nil)))) (defmethod remove-selection :after ((self patch-editor)) (let ((inspector (get-g-component self :inspector))) (when (and inspector (not (find (object inspector) (append (boxes (object self)) (connections (object self))) :test 'equal))) (update-inspector-for-editor self nil)))) ;;;====================================== ;;; OPTIONAL SIDE PANEL (GENERAL) ;;;====================================== (defmethod patch-editor-set-window-config ((self patch-editor) mode) (unless (equal (editor-window-config self) mode) (setf (editor-window-config self) mode) (build-editor-window self) (init-editor-window self) ;(when (equal (editor-window-config self) :inspector) ; (or (update-inspector-for-editor self) ; (set-inspector-contents (get-g-component self :inspector) nil)) ; ) )) (defmethod make-layout-items ((editor patch-editor)) (om-make-layout 'om-column-layout :subviews (append (when (editor-window-config editor) (list (om-make-view 'om-view :subviews (list (om-make-graphic-object 'om-icon-button :icon :xx :icon-pushed :xx-pushed :size (omp 12 12) :action #'(lambda (b) (declare (ignore b)) (patch-editor-set-window-config editor nil)) ))) nil)) (list (om-make-view 'om-view :subviews (list (om-make-graphic-object 'om-icon-button :size (omp 16 16) :position (omp 0 0) :icon :info-gray :icon-disabled :info :lock-push nil :enabled (not (equal (editor-window-config editor) :inspector)) :action #'(lambda (b) (declare (ignore b)) (patch-editor-set-window-config editor (if (equal (editor-window-config editor) :inspector) nil :inspector))) ) (om-make-graphic-object 'om-icon-button :size (omp 16 16) :position (omp 0 18) :icon :lisp-gray :icon-disabled :lisp :lock-push nil :enabled (not (equal (editor-window-config editor) :lisp-code)) :action #'(lambda (b) (declare (ignore b)) (patch-editor-set-window-config editor (if (equal (editor-window-config editor) :lisp-code) nil :lisp-code))) ) (om-make-graphic-object 'om-icon-button :size (omp 16 16) :position (omp 0 36) :icon :listen-gray :icon-disabled :listen :lock-push nil :enabled (not (equal (editor-window-config editor) :listener)) :action #'(lambda (b) (declare (ignore b)) (patch-editor-set-window-config editor (if (equal (editor-window-config editor) :listener) nil :listener))) ))) nil ;;; space at the bottom )) )) (defmethod make-editor-window-contents ((editor patch-editor)) (let ((patch-view (call-next-method)) (layout-items (make-layout-items editor))) (set-g-component editor :lisp-code nil) (set-g-component editor :listener nil) (set-g-component editor :inspector nil) (if (editor-window-config editor) ;; non-NIL ;;; patch editor with side-panel (let ((side-pane (om-make-layout 'om-column-layout :ratios '(nil nil 1) :delta 10 :subviews (list ;; top of the pane (om-make-di 'om-simple-text :size (omp 230 18) :font (om-def-font :gui-title) :text (case (editor-window-config editor) (:lisp-code "Lisp code") (:listener "listener / system out") (:inspector "info and properties")) :fg-color (om-def-color :dark-gray)) :separator ;; main pane (cond ((equal (editor-window-config editor) :lisp-code) (make-lisp-code-pane editor)) ((equal (editor-window-config editor) :listener) (make-listener-pane editor)) ((equal (editor-window-config editor) :inspector) (make-inspector-pane editor)) (t nil)) )) )) (values (case (editor-window-config editor) (:inspector (om-make-layout 'om-row-layout :delta 2 :ratios '(1 nil nil) :subviews (list patch-view side-pane layout-items))) (otherwise (om-make-layout 'om-row-layout :delta 2 :ratios '(10 nil 1 nil) :subviews (list patch-view :divider side-pane layout-items)))) patch-view)) ;; normal patch editor (values (om-make-layout 'om-row-layout :ratios '(1 nil) :subviews (list patch-view layout-items)) patch-view) ) )) ;;;====================================== ;;; OPEN-AS-TEXT ;;;====================================== (defclass patch-text-editor-window (om-lisp::om-text-editor-window) ()) (defun find-patch-text-editor-for-file (path) (find path (om-get-all-windows 'patch-text-editor-window) :key 'om-lisp::file :test #'equal)) (defun find-patch-editor-for-file (path) (let ((de (find-doc-entry path))) (when de (editor (doc-entry-doc de))))) (defmethod patch-editor-open-text-editor ((self patch-editor)) (let* ((path (pathname (mypathname (object self)))) (win (find-patch-text-editor-for-file path))) (if win (om-select-window win) (om-lisp::om-open-text-editor :class 'patch-text-editor-window :contents path :lisp t)))) ;;; update the patch when the text editor is saved (defmethod om-lisp::save-text-file :after ((self patch-text-editor-window)) (let ((patch-ed (find-patch-editor-for-file (om-lisp::file self)))) (when patch-ed (funcall (revert-command patch-ed))))) ;;; update text editor when the patch is saved (defmethod save-document :after ((self OMPatch)) (when (mypathname self) (let ((text-win (find-patch-text-editor-for-file (pathname (mypathname self))))) (when text-win (om-lisp::revert-text-file text-win)) )))

Common Lisp

.lisp

cac-t-u-s/om-sharp

GPL-3.0

9/19/2024, 11:25:22 AM (Europe/Amsterdam)

d152683efdafb674242272f14ba864a160f5143f61ef579b0b1e9a31a020ec8e

boxpatch.lisp

cac-t-u-s_om-sharp/src/visual-language/patch/boxpatch.lisp

;============================================================================ ; om#: visual programming language for computer-assisted music composition ;============================================================================ ; ; This program is free software. For information on usage ; and redistribution, see the "LICENSE" file in this distribution. ; ; This program 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. ; ;============================================================================ ; File author: J. Bresson ;============================================================================ ;========================================================================= ;PATCH IN PATCH ;========================================================================= (in-package :om) (defclass OMBoxPatch (OMBoxAbstraction) ()) (defmethod special-box-p ((name (eql 'patch))) t) (defmethod special-box-p ((name (eql 'p))) t) (defmethod get-box-class ((self OMPatch)) 'OMBoxPatch) (defmethod omNG-make-special-box ((reference (eql 'patch)) pos &optional init-args) (omNG-make-new-boxcall (make-instance 'OMPatchInternal :name (if init-args (format nil "~A" (car (list! init-args))) "new-patch")) pos init-args ;; don't need to pass them in principle.. )) (defmethod omNG-make-special-box ((reference (eql 'p)) pos &optional init-args) (omNG-make-special-box 'patch pos init-args)) (defmethod update-from-reference ((self OMBoxPatch)) (when *erased-io* (let ((io (find *erased-io* (append (inputs self) (outputs self)) :key 'reference))) (when (and io (container self)) (mapc #'(lambda (c) (omng-remove-element (container self) c)) (connections io))))) (call-next-method)) ;;; set the caller as the first reference so that the meta-inputs work (defmethod omng-box-value :before ((self OMBoxPatch) &optional numout) (setf (references-to (reference self)) (cons self (remove self (references-to (reference self)))))) ;;;------------------------------------------------------- ;;; DISPLAY ;;;======================== ;;; when the value is a box: ;;;======================== (defmethod display-modes-for-object ((self OMPatch)) '(:mini-view :hidden :value)) (defmethod object-for-miniview ((self OMBoxPatch)) (reference self)) ;;; the value of the box is a Box... (defmethod draw-mini-view ((object OMBoxEditCall) (box OMBox) x y w h &optional time) (om-draw-rect (+ x 2) (+ y 4) (- w 4) (- h 16) :fill t :color (om-def-color :white)) ;(om-draw-rect (+ x 2) (+ y 4) (- w 4) (- h 16) :fill nil :color (om-def-color :dark-gray) :line 1.5) (draw-mini-view (get-box-value object) box (+ x 8) (+ y 4) (- w 12) (- h 16) nil)) ;;; to draw the mini-view... (defmethod get-edit-param ((self OMBoxPatch) param) (get-patch-value-edit-param (get-box-value self) param)) (defmethod get-patch-value-edit-param ((self t) param) (find-value-in-kv-list (object-default-edition-params self) param)) (defmethod get-patch-value-edit-param ((self object-with-edit-params) param) (get-edit-param self param)) ;;; from inspector (defmethod set-property ((object OMBoxPatch) (prop-id (eql :display)) val) (reset-cache-display object) (call-next-method)) ;;; patch can draw either the patch or the value: ;;; cache display must be reinitialized (defmethod set-display ((self OMBoxPatch) val) (reset-cache-display self) (call-next-method)) (defmethod draw-mini-view ((self OMPatch) box x y w h &optional time) (flet ((pos-to-x (xpos) (+ x 15 (round (* xpos (- w 30))))) (pos-to-y (ypos) (+ y 12 (round (* ypos (- h 36)))))) (ensure-cache-display-draw box self) (om-with-fg-color (om-def-color :gray) ;; connections (loop for c in (cadr (get-display-draw box)) do (when (and (car c) (cadr c)) ;; 2 boxes ok (let* ((from (nth (car c) (car (get-display-draw box)))) (to (nth (cadr c) (car (get-display-draw box)))) (from-x (pos-to-x (car from))) (from-y (pos-to-y (cadr from))) (to-x (pos-to-x (car to))) (to-y (pos-to-y (cadr to))) (mid-x (+ from-x (round (- to-x from-x) 2))) (mid-y (+ from-y (round (- to-y from-y) 2)))) ;(om-draw-line (pos-to-x (car from)) (pos-to-y (cadr from)) ; (pos-to-x (car to)) (pos-to-y (cadr to))) (if (>= to-y from-y) (progn (om-draw-line from-x from-y from-x mid-y) (om-draw-line from-x mid-y to-x mid-y) (om-draw-line to-x mid-y to-x to-y)) (progn (om-draw-line from-x from-y mid-x from-y) (om-draw-line mid-x from-y mid-x to-y) (om-draw-line mid-x to-y to-x to-y))) ))) ;; boxes (loop for b in (car (get-display-draw box)) do (cond ((equal :b (caddr b)) (om-draw-rounded-rect (- (pos-to-x (car b)) 8) (- (pos-to-y (cadr b)) 4) 16 8 :round 2 :fill t)) ((equal :v (caddr b)) (om-draw-rect (- (pos-to-x (car b)) 4) (- (pos-to-y (cadr b)) 3) 8 6 :fill t)) (t (om-with-fg-color (cond ((equal :in (caddr b)) (om-make-color 0.2 0.6 0.2)) ((equal :out (caddr b)) (om-make-color 0.3 0.6 0.8)) (t (om-def-color :gray))) ;(om-draw-circle (pos-to-x (car b)) (pos-to-y (cadr b)) 3.4 :fill t)) (om-draw-rounded-rect (- (pos-to-x (car b)) 5) (- (pos-to-y (cadr b)) 4) 10 8 :round 2 :fill t)) ))) ))) (defmethod get-cache-display-for-draw ((self OMPatch) box) (declare (ignore box)) (let* ((patch self) (p-boxes (append (get-boxes-of-type patch 'OMBoxCall) (get-boxes-of-type patch 'OMInterfaceBox))) (bboxes (loop for b in p-boxes collect (list (box-x b) (+ (box-y b) (/ (box-h b) 2)) (cond ((subtypep (type-of b) 'ominbox) :in) ((subtypep (type-of b) 'omoutbox) :out) ((subtypep (type-of b) 'omboxeditcall) :b) ((subtypep (type-of b) 'OMInterfaceBox) :b) ((subtypep (type-of b) 'omvaluebox) :v) )))) (cconecs (loop for c in (connections patch) collect (list (position (box (from c)) p-boxes) (position (box (to c)) p-boxes))))) (when bboxes (let* ((x0 (apply #'min (mapcar 'car bboxes))) (xs (max 10 (- (apply #'max (mapcar 'car bboxes)) x0))) (y0 (apply #'min (mapcar 'cadr bboxes))) (ys (max 10 (- (apply #'max (mapcar 'cadr bboxes)) y0)))) (setf bboxes (loop for bb in bboxes collect (list (float (/ (- (car bb) x0) xs)) (float (/ (- (cadr bb) y0) ys)) (caddr bb)))) (list bboxes cconecs)) )))

Common Lisp

.lisp

cac-t-u-s/om-sharp

GPL-3.0

9/19/2024, 11:25:22 AM (Europe/Amsterdam)

2934683b9bf4972ed926afbe3228338a8b36f83034229ec17600b45cc8c1b80e

box-io.lisp

cac-t-u-s_om-sharp/src/visual-language/patch/box-io.lisp

;============================================================================ ; om#: visual programming language for computer-assisted music composition ;============================================================================ ; ; This program is free software. For information on usage ; and redistribution, see the "LICENSE" file in this distribution. ; ; This program 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. ; ;============================================================================ ; File author: J. Bresson ;============================================================================ (in-package :om) ;;;============================= ; INPUTS/OUTPUTS OF A BOX ;;;============================= ;; reference can be an actual in/out box (e.g. in an abstraction box) ;; or just a symbol (never used) corresponding to the name of the input (defclass OMBoxIO (OMVPObject) ((reference :initform nil :initarg :reference :accessor reference) (doc-string :initform nil :initarg :doc-string :accessor doc-string) (value :initform nil :initarg :value :accessor value) (connections :initform nil :accessor connections :initarg :connections) (box :initform nil :initarg :box :accessor box) (area :initform nil :initarg :area :accessor area) (reactive :initform nil :initarg :reactive :accessor reactive) )) (defmethod copy-io ((self OMBoxIO)) (let ((new-io (make-instance (type-of self) :value (value self) :reference (reference self) :name (name self) :box (box self) :reactive (reactive self) :doc-string (doc-string self)))) (setf (connections new-io) (mapcar #'(lambda (c) (adopt-connection new-io c)) (connections self))) new-io)) (defclass box-input (OMBoxIO) ()) (defclass box-output (OMBoxIO) ()) ;;; just for display in tooltips etc. (defmethod io-prefix ((self OMBoxIO)) "") (defmethod set-value ((self OMBoxIO) value) (setf (value self) value)) ;;; the doc-string can be either hard-coded, or collected from the class/method definition (defmethod get-input-doc-string ((self OMBoxIO)) (let ((doc (or (doc-string self) (get-input-doc (box self) (name self))))) (and (stringp doc) (not (string-equal doc "")) doc))) (defmethod get-input-doc ((self OMBox) name) nil) (defmethod get-input-menu ((self OMBox) name) nil) (defmethod get-input-def-value ((self OMBox) name) nil) (defmethod get-output-doc ((self OMBox) i) nil) ; (format nil "out~D" i)) ;---------------------------------------------------- ; BOXES CAN HAVE SPECIAL OPTIONAL / KEYWORD INPUTS ;---------------------------------------------------- (defclass box-optional-input (box-input) ()) (defclass box-keyword-input (box-input) ()) (defmethod keyword-input-p ((self t)) nil) (defmethod keyword-input-p ((self box-keyword-input)) t) (defmethod get-optional-inputs ((box OMBox)) (remove-if-not #'(lambda (item) (subtypep item 'box-optional-input)) (inputs box) :key 'type-of)) (defmethod get-keyword-inputs ((box OMBox)) (remove-if-not #'(lambda (item) (subtypep item 'box-keyword-input)) (inputs box) :key 'type-of)) (defmethod get-standard-inputs ((box OMBox)) (remove-if #'(lambda (item) (or (subtypep item 'box-keyword-input) (subtypep item 'box-optional-input))) (inputs box) :key 'type-of)) ;;; used (?) for subclasses such as patch boxes, loop boxes, sequence... (defmethod do-delete-one-input-extra ((self OMBox)) nil) (defmethod next-optional-input ((self OMBox)) nil) (defmethod more-optional-input ((self t) &key name value doc reactive) (declare (ignore name value doc reactive)) nil) (defmethod add-optional-input ((self OMBox) &key name value doc reactive) (set-box-inputs self (append (inputs self) (list (make-instance 'box-optional-input :name (string-downcase name) :value value :box self :doc-string (or doc "optional input") :reactive reactive))))) (defmethod remove-one-optional-input ((self OMBox)) (let ((optionals (get-optional-inputs self))) (when optionals (let ((last-in (car (last optionals)))) (mapcar #'(lambda (c) (omng-remove-element (container self) c)) (connections last-in)) (set-box-inputs self (remove last-in (inputs self) :test 'equal)) (do-delete-one-input-extra self) t)))) (defmethod get-all-keywords ((self t)) nil) (defmethod next-keyword-input ((self OMBox)) (let ((keywordlist (apply 'append (get-all-keywords self))) (usedkeywords (mapcar #'(lambda (in) (intern-k (name in))) (get-keyword-inputs self)))) (if keywordlist (or (find-if-not #'(lambda (elt) (member elt usedkeywords)) keywordlist) (values nil "All keywords are already used..")) (values nil (string+ "No keyword for box '" (name self) "'."))) )) (defmethod io-prefix ((self box-keyword-input)) ":") ;(defmethod more-keyword-input ((self t) &key name (value nil val-supplied-p) doc reactive) nil) (defmethod def-reactive ((self OMBox) key) nil) (defmethod more-keyword-input ((self OMBox) &key key (value nil val-supplied-p) doc (reactive nil reactive-supplied-p)) (multiple-value-bind (def-next err-message) (next-keyword-input self) (if def-next ;;; a keyword exist/is available (let ((keyname (if key ;;; a specific name is asked for (let ((keywordlist (mapcar 'intern-k (apply 'append (get-all-keywords self)))) (usedkeywords (mapcar #'(lambda (in) (intern-k (name in))) (get-keyword-inputs self)))) (and (or (find (intern-k key) keywordlist) (find (intern-k (box-free-keyword-name self)) keywordlist) (om-beep-msg "Unknown keyword name in box ~A: ~A" (name self) key) ;(intern-k key) ; uncomment this if we want to return the keyword anyway... ) (or (not (find (intern-k key) usedkeywords)) (om-beep-msg "Keyword name already used in box ~A: ~A" (name self) key)) (intern-k key))) ;;; key is ok def-next))) (when keyname (add-keyword-input self :key keyname :value (if val-supplied-p value (get-input-def-value self keyname)) :doc (or doc (get-input-doc self (string-downcase keyname))) :reactive (if reactive-supplied-p reactive (def-reactive self keyname))) t)) (om-beep-msg err-message) ))) (defmethod add-keyword-input ((self OMBox) &key key value doc reactive) (set-box-inputs self (append (inputs self) (list (make-instance 'box-keyword-input :name (string-downcase key) ;; string-downcase :value value :box self :doc-string (or doc "keyword input") :reactive reactive ))))) (defmethod remove-one-keyword-input ((self OMBox)) (let ((keywords (get-keyword-inputs self))) (when keywords (let ((last-in (car (last keywords)))) (mapcar #'(lambda (c) (omng-remove-element (container self) c)) (connections last-in)) (set-box-inputs self (remove last-in (inputs self) :test 'equal)) t)))) ;;; :++ is a special keyword to set a personalized keyword name ;;; used for instance in class-array (defmethod box-free-keyword-name ((self t)) :++) (defmethod change-keyword ((input box-keyword-input) key) (let ((old-name (name input)) (new-key (if (equal key (box-free-keyword-name (box input))) (let ((new-name (om-get-user-string "type a new name" :initial-string (name input)))) (and new-name (intern-k new-name))) key))) (when new-key (setf (name input) (string-downcase new-key) (value input) (get-input-def-value (box input) new-key) (doc-string input) (get-input-doc (box input) (string-downcase new-key)) (reactive input) (def-reactive (box input) new-key)) (update-output-from-new-in (box input) old-name input) ))) (defmethod update-output-from-new-in (box name in) nil) (defmethod smart-copy-additional-inputs ((self OMBox) newbox) ;;; if boxes have common inputs (in principle, they do!) => copy the values (loop for in in (inputs self) do (let ((newin (find (name in) (inputs newbox) :key 'name :test 'string-equal))) (when newin (setf (value newin) (om-copy (value in))) (setf (reactive newin) (reactive in))) )) (loop for out in (outputs self) do (let ((newout (find (name out) (outputs newbox) :key 'name :test 'string-equal))) (when newout (setf (reactive newout) (reactive out))) )) ;;; add relevant optional and keyword inputs (mapcar #'(lambda (in) (more-optional-input newbox :name (name in) :value (value in) :doc (doc-string in) :reactive (reactive in))) (get-optional-inputs self)) (mapcar #'(lambda (in) (more-keyword-input newbox :key (intern-k (name in)) :value (value in) :doc (doc-string in) :reactive (reactive in))) (get-keyword-inputs self)) ) (defmethod om-copy ((self OMBox)) (let ((newbox (call-next-method))) ;;; add the optional/keywords + copy input values (smart-copy-additional-inputs self newbox) newbox)) (defmethod optional-input++ ((self OMBox)) (more-optional-input self) (when (frame self) (set-frame-areas (frame self)) (om-invalidate-view (frame self)))) (defmethod optional-input-- ((self OMBox)) (remove-one-optional-input self) (when (frame self) (set-frame-areas (frame self)) (om-invalidate-view (frame self)) (om-invalidate-view (om-view-container (frame self))) ;; in case there were connections... )) (defmethod keyword-input++ ((self OMBox)) (more-keyword-input self) (when (frame self) (set-frame-areas (frame self)) (om-invalidate-view (frame self)))) (defmethod keyword-input-- ((self OMBox)) (remove-one-keyword-input self) (when (frame self) (set-frame-areas (frame self)) (om-invalidate-view (om-view-container (frame self))) ;; in case there were connections... )) ;------------------------------------------- ; SPECIAL OUTPUTS CORRESPONDING TO KEYWORD/OPTIONAL INPUTS ;------------------------------------------- (defclass box-keyword-output (box-output) ()) (defclass box-optional-output (box-output) ()) (defun get-keyword-outputs (box) (remove-if-not #'(lambda (item) (subtypep item 'box-keyword-output)) (outputs box) :key 'type-of)) (defun get-optional-outputs (box) (remove-if-not #'(lambda (item) (subtypep item 'box-optional-output)) (outputs box) :key 'type-of)) (defun get-standard-outputs (box) (remove-if #'(lambda (item) (or (subtypep item 'box-keyword-output) (subtypep item 'box-optional-output))) (outputs box) :key 'type-of)) (defmethod remove-one-output ((self ombox) (output box-output)) (mapc #'(lambda (c) (omng-remove-element (container self) c)) (connections output)) (set-box-outputs self (remove output (outputs self))))

Common Lisp

.lisp

cac-t-u-s/om-sharp

GPL-3.0

9/19/2024, 11:25:22 AM (Europe/Amsterdam)

f9de28cf1ef6f7b51ee52c98fffa2a9c4a4ca2198c981f9b8775a3156ca10dbf

lost-reference.lisp

cac-t-u-s_om-sharp/src/visual-language/patch/lost-reference.lisp

;============================================================================ ; om#: visual programming language for computer-assisted music composition ;============================================================================ ; ; This program is free software. For information on usage ; and redistribution, see the "LICENSE" file in this distribution. ; ; This program 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. ; ;============================================================================ ; File author: J. Bresson ;============================================================================ (in-package :om) ;------------------------------------------- ; BOX FOR LOST FUNCTIONS ;------------------------------------------- ; THIS BOX IS CREATED IF THE BOX IS NOT FOUND ; IN PRINCIPLE IT SHOULD NEVER BE SAVED BUT ; RE-SAVE THE ORIGINAL REFERENCE BOX (defclass LostReferenceBox (OMBoxCall) ((reference-type :accessor reference-type :initform nil :initarg :reference-type) (lost-reference :accessor lost-reference :initform nil :initarg :lost-reference)) (:default-initargs :reference :missing-reference) (:metaclass omstandardclass)) (defmethod get-icon-id ((self LostReferenceBox)) :dead) (defmethod object-name-in-inspector ((self LostReferenceBox)) (format nil "Dead box [~A]" (string-upcase (lost-reference self)))) (defmethod get-documentation ((self LostReferenceBox)) (format nil "The reference of this box is unknown: ~A ~A. It was probably defined in some external file or library that is currently not loaded. " (reference-type self) (string-upcase (lost-reference self)))) ;; hacks the accessors (defmethod box-draw-color ((self LostReferenceBox)) (om-make-color .9 0.8 0.7)) (defmethod box-draw-text-color ((self LostReferenceBox)) (om-make-color .8 0. 0.)) (defmethod border ((self LostReferenceBox)) nil) (defmethod box-draw ((self LostReferenceBox) frame) (unless (icon frame) (setf (icon frame) (om-load-picture-for-view :dead frame))) (om-draw-picture (icon frame) :x 2 :y 6 :w 18 :h 18) t) ;; for object boxes (defmethod (setf window-pos) (pos (self LostReferenceBox)) nil) (defmethod (setf window-size) (pos (self LostReferenceBox)) nil) (defmethod maximum-size ((self LostReferenceBox)) nil) ;(defmethod draw-border ((self LostReferenceBox) x y w h style) ; (om-draw-rect x y w h :line (if (numberp style) style 3) :color (om-make-color 0.9 0.4 0.4) :angles :round)) ;;; RE-SAVE AS IF EVERYTHING OK... (defmethod save-box-reference ((self LostReferenceBox)) (omng-save (lost-reference self))) (defmethod box-type ((self LostReferenceBox)) (reference-type self)) ;;; EVAL/GEN-CODE (defmethod omNG-box-value ((self LostReferenceBox) &optional (numout 0)) (om-beep-msg "MISSING REFERENCE FOR BOX [~A ~A]" (reference-type self) (lost-reference self)) (abort-eval)) (defmethod gen-code ((self LostReferenceBox) &optional numout) (error (format nil "MISSING REFERENCE FOR BOX [~A ~A]" (reference-type self) (lost-reference self)))) ;;; we have to expliciely copy the inputs and outputs ;;; and not le the default mechanism work (defmethod update-from-reference ((self LostReferenceBox)) nil) (defmethod smart-copy-additional-inputs ((self LostReferenceBox) newbox) nil) (defmethod om-copy ((self LostReferenceBox)) (let ((newbox (call-next-method))) ;;; add the in/outs (setf (inputs newbox) (mapcar #'(lambda (i) (make-instance (type-of i) :value (om-copy (value i)) :reference (reference i) :name (name i) :box newbox :doc-string (doc-string i))) (inputs self))) (setf (outputs newbox) (mapcar #'(lambda (o) (make-instance (type-of o) :value (om-copy (value o)) :reference (reference o) :name (name o) :box newbox :doc-string (doc-string o))) (outputs self))) newbox)) (defun restore-inputs-from-saved-desc (box desc) (loop for input-desc in desc do (let ((type (find-value-in-kv-list (cdr input-desc) :type)) (name (find-value-in-kv-list (cdr input-desc) :name)) (val (find-value-in-kv-list (cdr input-desc) :value)) (reac (find-value-in-kv-list (cdr input-desc) :reactive))) (case type (:standard (setf (inputs box) (append (inputs box) (list (make-instance 'box-input :box box :name name :reference (intern name) :value (omng-load val) :reactive reac))))) (:optional (add-optional-input box :name name :value (omng-load val) :reactive reac)) (:key (add-keyword-input box :key name :value (omng-load val) :reactive reac)) )))) (defmethod restore-inputs ((self LostReferenceBox) inputs) (restore-inputs-from-saved-desc self inputs)) (defun restore-outputs-from-saved-desc (box desc) (setf (outputs box) (loop for output-desc in desc for i from 0 collect (let* ((name (find-value-in-kv-list (cdr output-desc) :name)) (reac (find-value-in-kv-list (cdr output-desc) :reactive))) (make-instance 'box-output :box box :name name :reference i :reactive reac)) ))) (defmethod restore-outputs ((self LostReferenceBox) outputs) (restore-outputs-from-saved-desc self outputs)) ;;; called if the output is requested, e.g. at loading an old patch (defmethod get-nth-output ((self LostReferenceBox) n) (or (nth n (outputs self)) (progn (setf (outputs self) (append (outputs self) (loop for i from (length (outputs self)) to n collect (make-instance 'box-output :box self :reference i)))) (nth n (outputs self))) )) ;;;=================== ;;; LOST FUNCTION ;;;=================== (defmethod omng-make-lost-fun-box (reference pos &optional init-args) (let* ((box (make-instance 'LostReferenceBox :lost-reference reference :reference-type :function))) (setf (name box) (string (lost-reference box))) (let ((size (default-size box))) ;;; default size will depend on the name (setf (box-x box) (om-point-x pos) (box-y box) (om-point-y pos) (box-w box) (om-point-x size) (box-h box) (om-point-y size))) box)) ;;;=================== ;;; LOST CLASS ;;;=================== (defmethod omng-make-lost-class-box (reference pos &optional init-args) (let* ((box (make-instance 'LostReferenceBox :lost-reference reference :reference-type :object))) (setf (box-x box) (om-point-x pos) (box-y box) (om-point-y pos) (text-align box) :center) (setf (name box) (string (lost-reference box))) box)) (defmethod omng-make-lost-slots-box (reference pos &optional init-args) (let* ((box (make-instance 'LostReferenceBox :lost-reference reference :reference-type :slots))) (setf (box-x box) (om-point-x pos) (box-y box) (om-point-y pos)) (setf (name box) (string (lost-reference box))) box)) #| ;;; test with function (defun testfun (a b &key c) (+ a b)) (fmakunbound 'testfun) ;;; test with class (defclass testclass () ((a :accessor a :initarg :a :initform nil) (b :accessor b :initarg :b :initform nil))) ;(make-instance 'testclass) ;(find-class 'testclass nil) (clos::remove-class-internal (find-class 'testclass nil)) |# ;;;=============================== ;;; MISSING ABSTRACTIONS ;;;=============================== ;;; For persistant abstraction boxes we play it differently: ;;; The box remaions but it highlighted until the refence is missing (i.e., file not found) ;;; The user can also go and look for the file by himself (defmethod lost-reference? ((self OMBoxAbstraction)) (and (is-persistant (reference self)) (mypathname (reference self)) (not (probe-file (mypathname (reference self)))))) (defmethod restore-inputs ((self OMBoxAbstraction) inputs) (if (lost-reference? self) (restore-inputs-from-saved-desc self inputs) (call-next-method))) (defmethod restore-outputs ((self OMBoxAbstraction) outputs) (if (lost-reference? self) (restore-outputs-from-saved-desc self outputs) (call-next-method))) (defmethod box-draw-text-color ((self OMBoxAbstraction)) (cond ((lost-reference? self) (om-make-color .8 0 0)) ((and (is-persistant (reference self)) (null (mypathname (reference self)))) (om-make-color .8 0.3 0.3)) (t (call-next-method)))) (defmethod box-draw-color ((self OMBoxAbstraction)) (if (lost-reference? self) (om-make-color 0.9 0.7 0.5) (call-next-method))) (defmethod draw-patch-icon :after ((self OMBoxAbstraction) icon &optional (offset-x 0) (offset-y 0)) (when (lost-reference? self) (let ((x1 (+ offset-x 8)) (x2 (+ offset-x (- 24 4))) (y1 (+ offset-y 10)) (y2 (+ offset-y (- 24 0)))) (om-with-fg-color (om-make-color-alpha (om-def-color :dark-red) .7) (om-with-line-size 3 (om-draw-line x1 y1 x2 y2) (om-draw-line x1 y2 x2 y1) ))))) (defmethod open-editor ((self OMBoxAbstraction)) (if (lost-reference? self) (progn (om-beep-msg "MISSING REFERENCE FOR BOX '~A'.~%[=> File '~s' not found]" (name self) (mypathname (reference self))) (setf (loaded? (reference self)) nil) ;; is it not ? ) (call-next-method))) (defmethod boxcall-function :before ((self OMBoxAbstraction)) (when (lost-reference? self) (om-beep-msg "MISSING REFERENCE FOR BOX '~A'.~%[=> File '~s' not found]" (name self) (mypathname (reference self))) (abort-eval))) (defmethod gen-code :before ((self OMBoxAbstraction) &optional numout) (when (lost-reference? self) (om-beep-msg "MISSING REFERENCE FOR BOX '~A'.~%[=> File '~s' not found]" (name self) (mypathname (reference self))) (abort-eval)))

Common Lisp

.lisp

cac-t-u-s/om-sharp

GPL-3.0

9/19/2024, 11:25:22 AM (Europe/Amsterdam)

d6577e1dcd89f95b5e7a4e23745c0b92ffd7d5e0939b27180e174f4beb8eeec0

reactive.lisp

cac-t-u-s_om-sharp/src/visual-language/patch/reactive.lisp

;============================================================================ ; om#: visual programming language for computer-assisted music composition ;============================================================================ ; ; This program is free software. For information on usage ; and redistribution, see the "LICENSE" file in this distribution. ; ; This program 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. ; ;============================================================================ ; File author: J. Bresson ;============================================================================ (in-package :om) ;;;================== ;;; REACTIVE STATUS ;;;================== ;;; returns the active inputs connected to the active outputs of self ;;; as a list of ((box input-name) ...) (defmethod get-listeners ((self OMBox)) (remove-duplicates (loop for o in (outputs self) when (reactive o) append (loop for c in (connections o) when (input-will-react (to c)) collect (list (box (to c)) (name (to c)))) ))) (defmethod input-will-react ((self box-input)) (and (reactive self) (not (equal (lock-state (box self)) :locked)))) ;;;================== ;;; NOTIFICATION ;;;================== (defmethod OMR-Notify ((self OMBox) &optional input-name) (unless (push-tag self) (setf (push-tag self) t) (let ((listeners (get-listeners self))) (if listeners (loop for listener in listeners do (omr-notify (car listener) (cadr listener))) (omNG-box-value self))))) ;;; SELF-NOTIFICATION (NOTIFIES AND REEVALUATES ON A NEW THREAD) (defmethod self-notify ((box OMBox) &optional (separate-thread t) (eval-box nil)) ;(print (list "SELF NOTIFY" (name box) (current-box-value box))) (let ((listeners (get-listeners box))) (when (or listeners eval-box) (let* ((panel (and (frame box) (om-view-container (frame box)))) (eval-form `(progn (setf *current-eval-panel* ,panel) (when ,eval-box (omng-box-value ,box)) ; => only when an input is modified (when ',listeners (setf (gen-lock ,box) t) (OMR-Notify ,box) (setf (gen-lock ,box) nil)) (when ,panel (clear-ev-once ,panel) (setf *current-eval-panel* nil)) ))) (if separate-thread (progn (prompt-on-listeners "Processing event...") (om-eval-enqueue eval-form :post-action #'(lambda () (prompt-on-listeners "Ready.")))) (eval eval-form)) )))) (defmethod clear-ev-once :around ((self OMBox)) (call-next-method) (setf (gen-lock self) nil) (setf (gen-flag self) nil) (setf (push-tag self) nil) (when (frame self) (om-invalidate-view (frame self)))) ;;;================= ;;; DEBUG/VISUALIZE EVALUATION ;;;================= (defparameter *box-color-time* .2) (defparameter *eval-color* (om-def-color :dark-red)) (defparameter *notify-color* (om-make-color 0.5 0.6 0.7)) (defun temp-box-color (box color &optional wait) (when wait (setf (color box) color) (when (frame box) (om-invalidate-view (frame box))) (when (plusp wait) (sleep wait)))) ;(push :debug-mode *features*) (defmacro with-coloured-box (box color time &body body) `(let ((init-color (color ,box))) (unwind-protect (progn (temp-box-color ,box ,color ,time) ,@body ) (temp-box-color ,box init-color ,time)))) #+debug-mode (defmethod OMR-Notify :around ((self OMBox) &optional input-name) (with-coloured-box self *notify-color* *box-color-time* (call-next-method))) ;;;================== ;;; BOX-VALUE ;;;================== #| (let ((val (call-next-method))) (setf (gen-flag self) t) (when (or (not (gen-flag self)) (and (equal (lock-state self) :eval-once) (not (ev-once-flag self))) (equal (lock-state self) nil)) (setf (gen-lock self) t) (self-notify self) (setf (gen-lock self) nil) ) val) |# ;;; extend to all boxes ? (e.g. Interface boxes) (defmethod omNG-box-value :around ((self OMBox) &optional (numout 0)) #+debug-mode (with-coloured-box self *eval-color* *box-color-time* (if (gen-lock self) (current-box-value self numout) (let ((val (call-next-method))) (setf (gen-flag self) t) val)) ) #-debug-mode (if (gen-lock self) (current-box-value self numout) (let ((val (call-next-method))) (setf (gen-flag self) t) val)) ) ;;;========================= ;;; EVENTS ;;;========================= ;;; when a box is evaluated (on request) (defmethod eval-box :around ((self OMBox)) (call-next-method) (setf (gen-lock self) t) ;;; note : in mode eval-once we must not launch the self-notification on a separate thread ;;; otherwise the clear-ev-once will be called too early (self-notify self nil) ; (not (equal (lock-state self) :eval-once))) (setf (gen-lock self) nil)) ;;; when an input is edited (defmethod set-value ((self box-input) value) (call-next-method) (when (reactive self) (self-notify (box self) t t))) ;;; when a value box is modified (defmethod set-value ((self OMValueBox) value) (call-next-method) (setf (reference self) (type-of (car value))) (when (reactive (car (outputs self))) (self-notify self))) ;;; when an editor reports to the box (defmethod update-from-editor :around ((self OMBoxEditCall) &key (value-changed t) (reactive t)) (declare (ignore value-changed)) (call-next-method) (when reactive (self-notify self t NIL)))

Common Lisp

.lisp

cac-t-u-s/om-sharp

GPL-3.0

9/19/2024, 11:25:22 AM (Europe/Amsterdam)

6d9a88acc8b07554adf6ff1481e81bc176a6b5e7eadf5a7ddfe81ae684869f66

interfacebox.lisp

cac-t-u-s_om-sharp/src/visual-language/patch/interfacebox.lisp

;============================================================================ ; om#: visual programming language for computer-assisted music composition ;============================================================================ ; ; This program is free software. For information on usage ; and redistribution, see the "LICENSE" file in this distribution. ; ; This program 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. ; ;============================================================================ ; File author: J. Bresson ;============================================================================ ;======================================================================= ; INTERFACE BOXES ;======================================================================= (in-package :om) (defclass OMInterfaceBox (OMBox) ()) (defmethod lock-state ((self OMInterfaceBox)) nil) (defmethod box-symbol ((self OMInterfaceBox)) 'interface) (defmethod get-properties-list ((self OMInterfaceBox)) (hide-property (call-next-method) '(:text-font :align :group-id))) (defmethod get-documentation ((self OMInterfaceBox)) (class-documentation (class-of self))) (defmethod create-box-outputs ((self OMInterfaceBox)) (list (make-instance 'box-output :box self :name "value"))) (defmethod maximum-size ((self OMInterfaceBox)) nil) (defmethod minimum-size ((self OMInterfaceBox)) (omp 20 28)) ;;; set the box attributes (defmethod apply-one-box-attribute ((self OMInterfaceBox) attr val) (setf (slot-value self (intern-om attr)) val)) (defmethod apply-one-box-attribute ((self OMInterfaceBox) (attr (eql :value)) val) (set-value self (list val))) (defmethod apply-box-attributes ((self OMInterfaceBox) attributes) (loop for attr on attributes by 'cddr do (apply-one-box-attribute self (car attr) (cadr attr))) (when (selected self) ;;; move out from the eval process to do that (capi:apply-in-pane-process (om-view-container (frame self)) 'update-inspector-for-object self) ) ) (defmethod omNG-box-value ((self OMInterfaceBox) &optional (numout 0)) (apply-box-attributes self (eval-box-inputs self)) (current-box-value self numout)) (defmethod gen-code ((self OMInterfaceBox) &optional (numout 0)) (current-box-value self numout)) ;(defmethod eval-box :before ((self OMInterfaceBox)) ; (apply-box-attributes self (eval-box-inputs self))) (defmethod get-state ((self OMInterfaceBox)) nil) (defmethod restore-state ((self OMInterfaceBox) state) nil) (defmethod omng-save ((self OMInterfaceBox)) (append (call-next-method) (list (save-value self)) (when (get-state self) `((:state ,(omng-save (get-state self))))))) (defmethod additional-slots-to-copy ((from OMInterfaceBox)) '(value)) (defmethod get-input-def-value ((self OMInterfaceBox) name) (when (slot-exists-p self (intern-om name)) (slot-value self (intern-om name)))) ;;; FRAME (defclass InterfaceBoxFrame (OMBoxFrame) ()) (defmethod get-box-frame-class ((self OMInterfaceBox)) 'InterfaceBoxFrame) (defmethod om-view-click-handler ((self InterfaceBoxFrame) position) ;;; this test avoids doing it when clicked on areas etc. (when (equal self (call-next-method)) (interfacebox-action (object self) self position) )) (defmethod interfacebox-action ((self OMInterfaceBox) frame pos) nil) (defmethod draw-interface-component ((self OMInterfaceBox) x y w h) nil) (defmethod boxframe-draw-contents ((self InterfaceBoxFrame) (box OMInterfaceBox)) (let ((io-hspace 4)) ;;; interior (when (box-draw-color box) (om-draw-rounded-rect 0 io-hspace (w self) (- (h self) (* 2 io-hspace)) :color (box-draw-color box) :round (box-draw-roundness box) :fill t)) (when (selected box) (om-draw-rounded-rect 0 io-hspace (w self) (- (h self) (* 2 io-hspace)) :color (om-make-color-alpha (om-def-color :gray) 0.3) :round (box-draw-roundness box) :fill t)) (draw-interface-component box 0 io-hspace (w self) (- (h self) (* 2 io-hspace))) ;;; border (when (and (box-draw-border box) (plusp (box-draw-border box))) (draw-border box 0 io-hspace (w self) (- (h self) (* 2 io-hspace)))) ;;; in/outs etc. (mapcar #'(lambda (a) (om-draw-area a)) (areas self)) )) ;;;=============================================================== ;;; CHECK-BOX ;;;=============================================================== (defclass CheckBoxBox (OMInterfaceBox) () (:documentation "An interface box to choose between T and NIL. Click with CMD (Mac) or Shift+Ctrl (Windows/Linux) to toggle the value. Returns T or NIL.")) (defmethod special-item-reference-class ((item (eql 'check-box))) 'CheckBoxBox) (defmethod special-box-p ((self (eql 'check-box))) t) (defmethod omNG-make-special-box ((reference (eql 'check-box)) pos &optional init-args) (let* ((box (make-instance 'CheckBoxBox :name "check-box" :reference 'check-box))) (setf (box-x box) (om-point-x pos) (box-y box) (om-point-y pos)) box)) (defmethod maximum-size ((self CheckBoxBox)) (om-make-point 40 40)) (defmethod draw-interface-component ((self CheckBoxBox) x y w h) (let* ((line-w 2) (border 4) (size (- (min w h) 10)) (x1 (- (/ w 2) (/ size 2))) (y1 (+ border (- (/ h 2) (/ size 2)))) (x2 (+ (/ w 2) (/ size 2))) (y2 (+ border (/ h 2) (/ size 2)))) (when (car (value self)) (om-draw-line x1 y1 x2 y2 :line line-w :color (om-def-color :dark-gray)) (om-draw-line x1 y2 x2 y1 :line line-w :color (om-def-color :dark-gray)) ))) (defmethod interfacebox-action ((self CheckBoxBox) frame pos) (when (or (om-action-key-down) (container-frames-locked (om-view-container frame))) (store-current-state-for-undo (editor (container self))) (set-value self (list (not (get-box-value self)))) (when (reactive (car (outputs self))) (self-notify self)) (om-invalidate-view frame))) ;;;=============================================================== ;;; SLIDER ;;;=============================================================== (defclass SliderBox (OMInterfaceBox) ((min-value :accessor min-value :initarg :min-value :initform 0) (max-value :accessor max-value :initarg :max-value :initform 100) (increment :accessor increment :initarg :increment :initform 1) (decimals :accessor decimals :initarg :decimals :initform 0) (orientation :accessor orientation :initarg :orientation :initform :vertical) (action :accessor action :initarg :action :initform nil)) (:documentation "An interface box to select a value via an interactive slider. Use the optional inputs or box properties to set the orientation, range, and increment of the slider. Click+drag with CMD (Mac) or Shift+Ctrl (Windows/Linux), or when the patch is locked, to change the selected value. Returns the current value.")) (defmethod special-item-reference-class ((item (eql 'slider))) 'SliderBox) (defmethod special-box-p ((self (eql 'slider))) t) (defmethod get-all-keywords ((self SliderBox)) '((:min-value :max-value :increment :decimals :orientation :action :value))) (defmethod default-value ((self SliderBox)) 50) (defmethod set-value ((self SliderBox) val) (when (numberp (car val)) (call-next-method))) (defmethod get-properties-list ((self SliderBox)) (add-properties (call-next-method) "Slider" `((:min-value "Min value" :number min-value (nil nil ,#'decimals)) (:max-value "Max value" :number max-value (nil nil ,#'decimals)) (:increment "Increment" :number increment (,#'min-incr ,#'max-value ,#'decimals)) (:decimals "Decimals" :number slider-decimals (0 10 0)) (:orientation "Orientation" (:vertical :horizontal) orientation) ))) (defmethod apply-one-box-attribute ((self SliderBox) attr val) (if (member attr '(:min-value :max-value :increment)) (when (numberp val) (setf (slot-value self (intern-om attr)) val)) (call-next-method))) (defun min-incr (slider) (float (expt 10 (- (decimals slider))))) (defun round-decimals (val dec) (if (zerop dec) (round val) (float (* (round (* val (expt 10 dec))) (expt 10 (- dec)))))) (defun slider-decimals (slider &optional (val nil val-supplied-p)) (if val-supplied-p (progn (setf (decimals slider) val (min-value slider) (round-decimals (min-value slider) val) (max-value slider) (round-decimals (max-value slider) val) (increment slider) (round-decimals (increment slider) val)) (when (car (value slider)) (setf (car (value slider)) (round-decimals (car (value slider)) val))) (update-inspector-for-object slider)) (decimals slider))) (defmethod default-size ((self SliderBox)) (omp 28 100)) (defmethod omNG-make-special-box ((reference (eql 'slider)) pos &optional init-args) (let* ((box (make-instance 'SliderBox :name "slider" :reference 'slider))) (set-value box (list (default-value box))) (setf (box-x box) (om-point-x pos) (box-y box) (om-point-y pos)) box)) (defmethod draw-interface-component ((self SliderBox) x y w h) (let* ((val (or (car (value self)) (default-value self))) (pos-ratio (/ (- val (min-value self)) (- (max-value self) (min-value self))))) (cond ((equal (orientation self) :vertical) (om-draw-line (+ x (* 2 (box-draw-border self))) (+ y (* (- 1 pos-ratio) h)) (- (+ x w) (* (box-draw-border self) 2)) (+ y (* (- 1 pos-ratio) h)) :color (om-def-color :dark-gray) :line 3)) ((equal (orientation self) :horizontal) (om-draw-line (+ x (* pos-ratio w)) (+ y (box-draw-border self)) (+ x (* pos-ratio w)) (- (+ y h) (box-draw-border self)) :color (om-def-color :dark-gray) :line 3)) ))) (defun sliderbox-pos-value (sbox frame pos) (let ((ratio (min 1 (max 0 (if (equal (orientation sbox) :vertical) (- 1 (/ (om-point-y pos) (h frame))) (/ (om-point-x pos) (w frame))))))) (round-decimals (+ (min-value sbox) (* (increment sbox) (round (* ratio (- (max-value sbox) (min-value sbox))) (increment sbox)))) (decimals sbox)))) (defmethod interfacebox-action ((self SliderBox) frame pos) (when (or (om-action-key-down) (container-frames-locked (om-view-container frame))) (flet ((slider-action (view pos) (let ((val (sliderbox-pos-value self view pos))) (unless (equal val (get-box-value self)) (set-value self (list val)) (when (reactive (car (outputs self))) (self-notify self)) (om-invalidate-view view) )))) (store-current-state-for-undo (editor (container self))) ;;; action for the click (slider-action frame pos) ;;; more if drag (om-init-temp-graphics-motion frame pos nil :motion #'slider-action) ))) ;;;=============================================================== ;;; BUTTON ;;;=============================================================== (defclass ButtonBox (OMInterfaceBox) ((send-value :accessor send-value :initarg :send-value :initform t) (text :accessor text :initarg :text :initform "") (pushed :accessor pushed :initform nil)) (:documentation "An interface box to trigger reactive updates. Use the optional inputs to set a value to send through, and/or text to display on the button. Click with CMD (Mac) or Shift+Ctrl (Windows/Linux), or when the patch is locked, to trigger. Returns the trigger value while pushed down, and NIL the rest of the time.")) (defmethod special-box-p ((self (eql 'button))) t) (defmethod special-item-reference-class ((item (eql 'button))) 'ButtonBox) (defmethod get-all-keywords ((self ButtonBox)) '((:send-value :text))) (defmethod get-properties-list ((self ButtonBox)) (add-properties (call-next-method) "Button" `((:send-value "Value sent" NIL send-value) (:text "Text" :string text) ))) (defmethod default-size ((self ButtonBox)) (omp 36 36)) (defmethod omNG-make-special-box ((reference (eql 'button)) pos &optional init-args) (let* ((box (make-instance 'ButtonBox :name "button" :reference 'button))) (setf (box-x box) (om-point-x pos) (box-y box) (om-point-y pos)) box)) (defmethod draw-interface-component ((self ButtonBox) x y w h) (let ((textcolor (if (pushed self) (om-def-color :light-gray) (om-def-color :dark-gray)))) (when (pushed self) (om-draw-rounded-rect x y w h :fill t :round (box-draw-roundness self) :color (om-def-color :gray))) (when (text self) (let ((font (om-def-font :normal-b))) (multiple-value-bind (sw sh) (om-string-size (text self) font) (om-with-fg-color textcolor (om-with-font font (om-draw-string (+ x (/ w 2) (- (/ sw 2))) (+ y (/ h 2) (- (/ sh 2)) 10) (text self))))))) )) (defmethod interfacebox-action ((self ButtonBox) frame pos) (when (or (om-action-key-down) (and (om-view-container frame) ;;; for some reason sometimes (e.g. while opening the inspector) the container becomes temporarily nil.. (container-frames-locked (om-view-container frame)))) (let ((val-input (find "send-value" (inputs self) :key 'name :test 'string-equal))) (when val-input (setf (send-value self) (omng-box-value val-input)))) (setf (pushed self) t) (set-value self (list (send-value self))) (om-invalidate-view frame) (when (reactive (car (outputs self))) (self-notify self)) (om-init-temp-graphics-motion frame pos nil :min-move nil :release #'(lambda (view pos) (declare (ignore view pos)) (set-value self nil) (setf (pushed self) nil) (om-invalidate-view frame) )))) (defmethod OMR-Notify ((self ButtonBox) &optional input-name) (cond ((and input-name (string-equal input-name "send-value")) (unless (push-tag self) (setf (push-tag self) t) (let ((listeners (get-listeners self))) (if listeners (progn (set-value self (list (send-value self))) (om-invalidate-view (frame self)) (loop for listener in listeners do (omr-notify (car listener) (cadr listener))) (set-value self nil) ) (omng-box-value self))))) (t (call-next-method)) )) (defmethod gen-code ((self ButtonBox) &optional (numout 0)) (let ((val-input (find "send-value" (inputs self) :key 'name :test 'string-equal))) (if val-input (gen-code val-input) (current-box-value self numout)))) ;;;=============================================================== ;;; LIST ;;;=============================================================== (defclass ListSelectionBox (OMInterfaceBox) ((items :accessor items :initarg :items :initform nil) (selection :accessor selection :initarg :selection :initform nil) (multiple-selection :accessor multiple-selection :initarg :multiple-selection :initform nil) (cell-height :accessor cell-height :initarg :cell-height :initform 12) (cell-font :accessor cell-font :initarg :cell-font :initform (om-def-font :normal)) (output-mode :accessor output-mode :initarg :output-mode :initform :value)) (:documentation "An interface box to graphically select among different items in a list. Use the optional inputs to set the list of items. Click with CMD (Mac) or Shift+Ctrl (Windows/Linux) to change the selected item. Returns the selected item, or the selected index depending on how this is set in the box properties. Can return a list of selected items if 'multiple selection' is enabled in the box properties." )) (defmethod special-box-p ((self (eql 'list-selection))) t) (defmethod special-item-reference-class ((item (eql 'list-selection))) 'ListSelectionBox) (defmethod default-size ((self ListSelectionBox)) (omp 60 60)) (defmethod maximum-size ((self ListSelectionBox)) (omp nil (max 60 (+ 16 (* (+ 2 (cell-height self)) (length (items self))))))) (defmethod get-all-keywords ((self ListSelectionBox)) '((:items))) (defmethod get-properties-list ((self ListSelectionBox)) (add-properties (call-next-method) "List selection display" `((:multiple-selection "Multiple selection" :bool multiple-selection) (:cell-height "Cell size (px)" :number cell-height (2 40)) (:cell-font "Cell font" :font cell-font) (:output-mode "Output mode" (:value :index) output-mode-accessor) ))) (defmethod update-value-from-selection ((self ListSelectionBox)) (set-value self (if (multiple-selection self) (if (equal (output-mode self) :value) (list (posn-match (items self) (selection self))) (list (selection self))) (if (equal (output-mode self) :value) (and (selection self) (list (nth (car (selection self)) (items self)))) (list (car (selection self))) ) ))) (defmethod output-mode-accessor ((self ListSelectionBox) &optional value) (when value (setf (output-mode self) value) (update-value-from-selection self)) (output-mode self)) (defmethod apply-box-attributes ((self ListSelectionBox) attributes) (when attributes (let ((newlist (getf attributes :items))) (unless (equal newlist (items self)) (setf (selection self) nil) (set-value self nil)) (let ((min-size (+ 8 (* (+ 2 (cell-height self)) (length newlist))))) (when (< (box-h self) min-size) (omng-resize self (omp (box-w self) min-size)) (reset-frame-size (frame self))) ) )) (call-next-method)) (defmethod omng-save ((self ListSelectionBox)) (append (call-next-method) `((:items ,(omng-save (items self))) (:selection ,(omng-save (selection self)))))) (defmethod load-box-attributes ((box ListSelectionBox) data) (setf (items box) (omng-load (find-value-in-kv-list data :items))) (setf (selection box) (omng-load (find-value-in-kv-list data :selection))) box) (defmethod omNG-make-special-box ((reference (eql 'list-selection)) pos &optional init-args) (let* ((box (make-instance 'ListSelectionBox :name "list-selection" :reference 'list-selection))) (setf (box-x box) (om-point-x pos) (box-y box) (om-point-y pos)) box)) (defmethod draw-interface-component ((self ListSelectionBox) x y w h) (om-with-clip-rect (frame self) x y w h (let* ((text-h (cadr (multiple-value-list (om-string-size "A" (cell-font self))))) (text-pos (if (>= text-h (cell-height self)) (cell-height self) (* .5 (+ (cell-height self) text-h))))) (om-with-font (cell-font self) (loop for i = 0 then (+ i 1) for yy = y then (+ yy (cell-height self)) while (< yy h) while (< i (length (items self))) do (when (member i (selection self)) (om-draw-rect 3 (+ yy 2) (- w 6) (cell-height self) :fill t :color (om-def-color :dark-gray))) (om-draw-string 5 (+ yy text-pos) (format nil "~A" (nth i (items self))) :color (if (member i (selection self)) (om-def-color :white) (om-def-color :black))) )) ) (when (> (* (cell-height self) (length (items self))) h) (om-draw-rect (- w 20) (- h 8) 16 10 :fill t :color (om-def-color :white)) (om-draw-string (- w 18) (- h 2) "...") ) )) (defmethod interfacebox-action ((self ListSelectionBox) frame pos) (when (or (om-action-key-down) (container-frames-locked (om-view-container frame))) (let* ((y (- (om-point-y pos) 4)) (n (floor y (cell-height self)))) (when (and (> (om-point-x pos) 5) (< (om-point-x pos) (- (w frame) 10)) (< n (length (items self)))) (store-current-state-for-undo (editor (container self))) (if (member n (selection self)) (setf (selection self) (remove n (selection self))) (setf (selection self) (if (multiple-selection self) (sort (cons n (selection self)) '<) (list n)))) (update-value-from-selection self) (when (reactive (car (outputs self))) (self-notify self)) (om-invalidate-view frame) )))) (defmethod box-key-action ((box ListSelectionBox) key) (case key (:om-key-up (when (items box) (let* ((ref-selection (or (car (selection box)) 0)) (new-selection (max 0 (1- ref-selection)))) (setf (selection box) (list new-selection)) (update-value-from-selection box) (when (reactive (car (outputs box))) (self-notify box)) (om-invalidate-view (frame box))))) (:om-key-down (when (items box) (let* ((ref-selection (or (car (selection box)) 0)) (new-selection (min (1- (length (items box))) (1+ ref-selection)))) (setf (selection box) (list new-selection)) (update-value-from-selection box) (when (reactive (car (outputs box))) (self-notify box)) (om-invalidate-view (frame box))))) (otherwise (call-next-method)))) ;;;=============================================================== ;;; MENU ;;;=============================================================== (defclass ListMenuBox (OMInterfaceBox) ((items :accessor items :initarg :items :initform nil) (selection :accessor selection :initarg :selection :initform 0) (output-mode :accessor output-mode :initarg :output-mode :initform :value) (font :accessor font :initarg :font :initform (om-def-font :normal-b))) (:documentation "An interface box to graphically select among different items in a list, using a drop-down menu. Use the optional inputs to set the list of items. Click with CMD (Mac) or Shift+Ctrl (Windows/Linux) to change the selected item. Returns the selected item, or the selected index depending on how this is set in the box properties." )) (defmethod special-box-p ((self (eql 'list-menu))) t) (defmethod special-item-reference-class ((item (eql 'list-menu))) 'ListMenuBox) (defmethod default-size ((self ListMenuBox)) (omp 100 30)) (defmethod maximum-size ((self ListMenuBox)) (omp nil 30)) (defmethod minimum-size ((self ListMenuBox)) (omp 100 30)) (defmethod get-all-keywords ((self ListMenuBox)) '((:items))) (defmethod get-properties-list ((self ListMenuBox)) (add-properties (call-next-method) "Menu selection display" `((:font "Font" :font font) (:output-mode "Output mode" (:value :index) output-mode-accessor) ))) (defmethod output-mode-accessor ((self ListMenuBox) &optional value) (when value (setf (output-mode self) value) (update-value-from-selection self)) (output-mode self)) (defmethod update-value-from-selection ((self ListMenuBox)) (set-value self (if (equal (output-mode self) :value) (and (selection self) (list (nth (selection self) (items self)))) (list (selection self)) ))) (defmethod apply-box-attributes ((self ListMenuBox) attributes) (when attributes (let ((newlist (getf attributes :items))) (unless (equal newlist (items self)) (setf (selection self) 0) (set-value self nil)))) (call-next-method)) (defmethod omng-save ((self ListMenuBox)) (append (call-next-method) `((:items ,(omng-save (items self))) (:selection ,(omng-save (selection self)))))) (defmethod load-box-attributes ((box ListMenuBox) data) (setf (items box) (omng-load (find-value-in-kv-list data :items))) (setf (selection box) (omng-load (find-value-in-kv-list data :selection))) box) (defmethod omNG-make-special-box ((reference (eql 'list-menu)) pos &optional init-args) (let* ((box (make-instance 'ListMenuBox :name "list-menu" :reference 'list-menu))) (setf (box-x box) (om-point-x pos) (box-y box) (om-point-y pos)) box)) (defmethod draw-interface-component ((self ListMenuBox) x y w h) (om-draw-rounded-rect x y 24 h :round (box-draw-roundness self) :color (om-def-color :gray) :fill t) (let* ((font (or (font self) (om-def-font :normal-b))) (text-h (cadr (multiple-value-list (om-string-size "A" font)))) (text-y-pos (if (>= text-h h) h (* .5 (+ h text-h 1))))) (om-with-font font (om-draw-string (+ x 30) text-y-pos (format nil "~A" (nth (selection self) (items self)))) ))) (defmethod interfacebox-action ((self ListMenuBox) frame pos) (when (or (om-action-key-down) (container-frames-locked (om-view-container frame))) (when (< (om-point-x pos) 30) (let ((menu (om-make-menu "list items" (loop for item in (items self) for i from 0 collect (let ((sel i)) (om-make-menu-item (format nil "~A" item) #'(lambda () (store-current-state-for-undo (editor (container self))) (setf (selection self) sel) (update-value-from-selection self) (when (reactive (car (outputs self))) (self-notify self)) (om-invalidate-view frame)) :selected (= i (selection self)) )))))) (om-open-pop-up-menu menu (om-view-container frame)) )))) ;;;=============================================================== ;;; SWITCH ;;;=============================================================== (defclass SwitchBox (OMInterfaceBox) ((selection :accessor selection :initarg :selection :initform nil) (multiple-selection :accessor multiple-selection :initarg :multiple-selection :initform nil)) (:documentation "An interface box to graphically select among different inputs. Use the optional inputs to add choices. Click with CMD (Mac) or Shift+Ctrl (Windows/Linux) to change the selected input. Can evaluate and return the ouputs of several selected options if 'multiple selection' is enabled in the box properties.")) (defmethod special-item-reference-class ((item (eql 'switch))) 'SwitchBox) (defmethod special-box-p ((self (eql 'switch))) t) (defmethod get-state ((self SwitchBox)) (selection self)) (defmethod restore-state ((self SwitchBox) state) (setf (selection self) state)) (defmethod omNG-make-special-box ((reference (eql 'switch)) pos &optional init-args) (let* ((box (make-instance 'SwitchBox :name "switch" :reference 'switch))) (setf (box-x box) (om-point-x pos) (box-y box) (om-point-y pos)) box)) (defmethod create-box-inputs ((self SwitchBox)) (list (make-instance 'box-input :name "opt1" :box self :value NIL :doc-string "option 1"))) (defmethod next-optional-input ((self SwitchBox)) t) (defmethod more-optional-input ((self SwitchBox) &key name (value nil val-supplied-p) doc reactive) (declare (ignore name doc)) (let ((n (1+ (length (inputs self))))) (add-optional-input self :name (format nil "opt~D" n) :value (if val-supplied-p value nil) :doc (format nil "option ~D" n) :reactive reactive) t)) (defmethod get-properties-list ((self SwitchBox)) (add-properties (call-next-method) "Switch options" `((:multiple-selection "Multiple selection" :bool multiple-selection) ))) (defmethod set-property ((self SwitchBox) (attr (eql :multiple-selection)) val) (call-next-method) (when (null val) (setf (selection self) (list (car (selection self)))))) (defmethod maximum-size ((self SwitchBox)) (om-make-point nil 40)) (defmethod draw-interface-component ((self SwitchBox) x y w h) (let* ((border 4) (n (length (inputs self))) (cell-w (/ (- w (* 2 border)) n)) (cell-h (- h (* 2 border)))) (dotimes (i n) (om-draw-rect (+ border (* i cell-w)) (+ 4 border) cell-w cell-h :color (om-def-color :dark-gray)) (when (find i (selection self)) (om-draw-rect (+ border (* i cell-w)) (+ 4 border) cell-w cell-h :color (om-def-color :dark-gray) :fill t)) ) )) (defmethod interfacebox-action ((self SwitchBox) frame pos) (when (or (om-action-key-down) (container-frames-locked (om-view-container frame))) (let* ((border 4) (n (length (inputs self))) (cell-w (/ (- (w frame) (* 2 border)) n)) (cell-h (- (h frame) (* 2 border))) (sel (floor (- (om-point-x pos) border) cell-w))) (when (and (> (om-point-y pos) (+ 4 border)) (< (om-point-y pos) cell-h) (< sel n)) (store-current-state-for-undo (editor (container self))) (if (member sel (selection self)) (setf (selection self) (remove sel (selection self))) (setf (selection self) (if (multiple-selection self) (sort (cons sel (selection self)) '<) (list sel)))) (when (reactive (car (outputs self))) (self-notify self t t)) ;;; evaluate (om-invalidate-view frame) (when (container self) (report-modifications (editor (container self)))) )))) (defmethod omNG-box-value ((self SwitchBox) &optional (numout 0)) (let ((vals (loop for sel in (list! (selection self)) collect (when (< sel (length (inputs self))) (omNG-box-value (nth sel (inputs self))))))) (set-value self (list (if (multiple-selection self) vals (car vals)))) ;;; numout always 0... (nth numout (value self)))) (defmethod gen-code ((self SwitchBox) &optional (numout 0)) (let ((vals (loop for sel in (list! (selection self)) collect (when (< sel (length (inputs self))) (gen-code (nth sel (inputs self))))))) (if (multiple-selection self) `(list .,vals) (car vals))))

Common Lisp

.lisp

cac-t-u-s/om-sharp

GPL-3.0

9/19/2024, 11:25:22 AM (Europe/Amsterdam)

f310ce230e376ae1b9f8fc6492d04fa6d76765fccf4acddaa937b8493165ee7f

loop.lisp

cac-t-u-s_om-sharp/src/visual-language/patch/loop.lisp

;============================================================================ ; om#: visual programming language for computer-assisted music composition ;============================================================================ ; ; This program is free software. For information on usage ; and redistribution, see the "LICENSE" file in this distribution. ; ; This program 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. ; ;============================================================================ ; File author: J. Bresson ;============================================================================ ;--------------------------------------- ; Loop Boxes ;--------------------------------------- (in-package :om) ;;;================================ ;;; ITERATORS ;;; for / while / in-list / on-list ;;;================================ ;;; MUST BE USED ALONG WITH ITERATE ;;; OTHERWISE THE VARIABLE IS NOT DECLARED / UPDATED (defclass OMPatchLoop (OMPatchComponent) ((it-var :initform (gentemp "IT-") :accessor it-var) (it-value :initform nil :accessor it-value))) (defmethod index ((self OMPatchLoop)) 0) (defclass OMPatchLoopBox (OMPatchComponentBox) ()) (defmethod get-box-class ((self OMPatchLoop)) 'OMPatchLoopBox) (defmethod box-symbol ((self OMPatchLoop)) 'loop) (defmethod get-icon-id ((self OMPatchLoopBox)) :iter) (defmethod create-box-inputs ((self OMPatchLoopBox)) (create-box-inputs-for-loop-box (reference self) self)) (defmethod create-box-outputs ((self OMPatchLoopBox)) (list (make-instance 'box-output :box self :value NIL :name "i" :doc-string "current value of loop iterator (bound during iterate)"))) (defmethod next-optional-input ((self OMPatchLoopBox)) (allow-optional-input (reference self) (inputs self))) ;; also returns the default value (defmethod allow-optional-input ((self OMPatchLoop) existing-inputs) nil) (defmethod more-optional-input ((self OMPatchLoopBox) &key name (value nil val-supplied-p) doc reactive) (declare (ignore name doc)) (add-optional-input self :name "by" :value (if val-supplied-p value (allow-optional-input (reference self) (inputs self))) :reactive reactive) t) (defmethod gen-loop-code-for-eval ((self OMPatchLoopBox)) (let ((inputs-code (loop for inp in (inputs self) collect `(omng-box-value ,inp)))) (gen-iteration-code (reference self) inputs-code))) (defmethod gen-loop-code-for-compile ((self OMPatchLoopBox) &optional (gen-fun 'gen-code)) ;(let ((curr-loop-context (pop-let-context))) (unwind-protect (gen-iteration-code (reference self) (loop for inp in (inputs self) collect (gen-code inp))) ;(push-let-context curr-loop-context) )) (defmethod gen-loop-iterator-update-code ((self OMPatchLoop)) `(do (setf (it-value ,self) ,(it-var self)))) ;;; called at the beginning of a loop (defmethod box-init-iterator-value ((self OMPatchLoopBox)) (init-iterator-value (reference self) (mapcar 'omng-box-value (inputs self)))) (defmethod init-iterator-value ((self OMPatchLoop) input-values) (declare (ignore input-values)) (setf (it-value self) nil)) (defmethod boxcall-value ((self OMPatchLoopBox)) (it-value (reference self))) (defmethod gen-code ((self OMPatchLoopBox) &optional numout) (it-var (reference self))) ;;;------------------------------------ ;;; DIFFERENT KINDS OF ITERATOR BOXES ;;;------------------------------------ (defclass OMLoopFor (OMPatchLoop) () (:documentation "Loop iterator: 'LIST' Can be connected to an ITERATE box to control the steps of the iteration (FOR I FROM <a> TO <b> BY <step>).")) (defmethod special-box-p ((name (eql 'loop-for))) t) (defmethod box-symbol ((self OMLoopFor)) 'loop-for) (defmethod special-item-reference-class ((item (eql 'loop-for))) 'OMLoopFor) (defmethod omNG-make-special-box ((reference (eql 'loop-for)) pos &optional init-args) (omNG-make-new-boxcall (make-instance 'OMLoopFor :name "loop-for") pos init-args)) (defmethod gen-iteration-code ((self OMLoopFor) &optional inputs) (append `(for ,(it-var self) from ,(or (car inputs) 0) to ,(or (cadr inputs) 0)) (when (caddr inputs) `(by ,(caddr inputs))))) (defmethod init-iterator-value ((self OMLoopFor) input-values) (setf (it-value self) (car input-values))) (defmethod create-box-inputs-for-loop-box ((self OMLoopFor) box) (list (make-instance 'box-input :box box :value 0 :name "from") (make-instance 'box-input :box box :value 10 :name "to"))) ;;; returns the default value (defmethod allow-optional-input ((self OMLoopFor) existing-inputs) (and (<= (length existing-inputs) 2) 1)) ;;;------------------------------------ (defclass OMLoopList (OMPatchLoop) ((looped-list :initform nil :accessor looped-list :initarg :looped-list)) (:documentation "Loop iterator: 'LIST' Can be connected to an ITERATE box to control the iteration via successive elements of a list (FOR ITEM IN <list> ...). The sound (optional) input is a function determining how to jump from one state to the next iteration (default = 'CDR).")) (defmethod special-box-p ((name (eql 'loop-list))) t) (defmethod box-symbol ((self OMLoopList)) 'loop-list) (defmethod special-item-reference-class ((item (eql 'loop-list))) 'OMLoopList) (defmethod omNG-make-special-box ((reference (eql 'loop-list)) pos &optional init-args) (omNG-make-new-boxcall (make-instance 'OMLoopList :name "loop-list") pos init-args)) (defmethod gen-iteration-code ((self OMLoopList) &optional inputs) (append `(for ,(it-var self) in ,(car inputs)) (when (cadr inputs) `(by ,(cadr inputs))))) (defmethod init-iterator-value ((self OMLoopList) input-values) (setf (it-value self) (car (car input-values)))) (defmethod create-box-inputs-for-loop-box ((self OMLoopList) box) (list (make-instance 'box-input :box box :value nil :name "list"))) ;;; returns the default value (defmethod allow-optional-input ((self OMLoopList) existing-inputs) (and (<= (length existing-inputs) 1) 'cdr)) ;;;------------------------------------ (defclass OMLoopTail (OMPatchLoop) ((looped-list :initform nil :accessor looped-list :initarg :looped-list)) (:documentation "Loop iterator: 'LIST TAIL' Can be connected to an ITERATE box to control the iteration via successive tails/CDR of a list (FOR ITEM ON <list> ...). The sound (optional) input is a function determining how to jump from one state to the next iteration (default = 'CDR).")) (defmethod special-box-p ((name (eql 'loop-tail))) t) (defmethod box-symbol ((self OMLoopTail)) 'loop-tail) (defmethod special-item-reference-class ((item (eql 'loop-tail))) 'OMLoopTail) (defmethod omNG-make-special-box ((reference (eql 'loop-tail)) pos &optional init-args) (omNG-make-new-boxcall (make-instance 'OMLoopTail :name "loop-tail") pos init-args)) (defmethod gen-iteration-code ((self OMLoopTail) &optional inputs) (append `(for ,(it-var self) on ,(car inputs)) (when (cadr inputs) `(by ,(cadr inputs))))) (defmethod init-iterator-value ((self OMLoopTail) input-values) (setf (it-value self) (car input-values))) (defmethod create-box-inputs-for-loop-box ((self OMLoopTail) box) (list (make-instance 'box-input :box box :value nil :name "list"))) ;;; returns the default value (defmethod allow-optional-input ((self OMLoopTail) existing-inputs) (and (<= (length existing-inputs) 1) 'cdr)) ;;;------------------------------------ (defclass OMLoopWhile (OMPatchLoop) ((loop-cond :initform nil :accessor loop-cond :initarg :loop-cond)) (:documentation "Loop iterator: 'WHILE' Can be connected to an ITERATE box to control when the iteration should stop (WHILE <condition> DO ...).")) (defmethod special-box-p ((name (eql 'loop-while))) t) (defmethod box-symbol ((self OMLoopWhile)) 'loop-while) (defmethod special-item-reference-class ((item (eql 'loop-while))) 'OMLoopWhile) (defmethod omNG-make-special-box ((reference (eql 'loop-while)) pos &optional init-args) (omNG-make-new-boxcall (make-instance 'OMLoopWhile :name "loop-while") pos init-args)) ;;; while goes after other iterators declarations (defmethod index ((self OMLoopWhile)) 1) (defmethod gen-iteration-code ((self OMLoopWhile) &optional inputs) (push-let-statement `(,(it-var self) nil)) ; with ,(it-var self) = nil `(while (setf ,(it-var self) ,(car inputs)))) (defmethod create-box-inputs-for-loop-box ((self OMLoopWhile) box) (list (make-instance 'box-input :box box :value t :name "condition"))) ;;;==================== ;;; ITERATE ;;;==================== ;;; - triggers iteration according to the ITERATORs found in the patch ;;; ALSO WORKS IN EVAL MODE: ;;; - can be evaluated alone ;;; - reinitializes the COLLECTORS before to start (or not?) ;;; - reinitializes the ITERATORS before to start ;;; - evaluates all iterators (defclass OMPatchIterator (OMPatchComponent) ((n-iter :accessor n-iter :initform 0 :initarg :n-iter)) (:documentation "Evaluation sink for Loops, used to program an iterative process. Add as many optional inputs as needed, and connect (directly or indirectly) to one or more including 'iterator' boxes: LOOP-LIST, LOOP-FOR, LOOP-WHILE...) Will be evaluate input(s) as many times as defined by the iterators.")) (defclass OMPatchIteratorBox (OMPatchComponentBox) ()) (defmethod special-box-p ((name (eql 'iterate))) t) (defmethod get-box-class ((self OMPatchIterator)) 'OMPatchIteratorBox) (defmethod box-symbol ((self OMPatchIterator)) 'iterate) (defmethod special-item-reference-class ((item (eql 'iterate))) 'OMPatchIterator) (defmethod get-ev-once-flag ((self OMPatchIteratorBox)) (list self (n-iter (reference self)))) (defmethod get-icon-id ((self OMPatchIteratorBox)) :s-loop) (defmethod object-name-in-inspector ((self OMPatchIteratorBox)) "ITERATOR box") (defmethod omNG-make-special-box ((reference (eql 'iterate)) pos &optional init-args) (let ((name (car (list! init-args)))) (omNG-make-new-boxcall (make-instance 'OMPatchIterator :name (if name (string name) "iterate")) pos init-args))) (defmethod create-box-inputs ((self OMPatchIteratorBox)) (list (make-instance 'box-input :box self :value NIL :name "action"))) (defmethod next-optional-input ((self OMPatchIteratorBox)) t) (defmethod get-input-doc ((self OMPatchIteratorBox) name) "to do at each iteration") (defmethod more-optional-input ((self OMPatchIteratorBox) &key name (value nil val-supplied-p) doc reactive) (declare (ignore name doc)) (add-optional-input self :name "action" :value (if val-supplied-p value nil) :reactive reactive) t) ;;; we want to put the while boxes at the end ;;; (they are the only ones that can be reevaluated and depend on other ones during the loop) (defmethod collect-loop-boxes ((self OMPatch)) (sort (get-boxes-of-type self 'OMPatchLoopBox) #'(lambda (type1 type2) (declare (ignore type2)) (if (subtypep type1 'OMLoopWhile) t nil)) :key 'type-of)) (defmethod boxcall-value ((self OMPatchIteratorBox)) (let ((old-context *ev-once-context*) (loopboxes (sort-boxes (remove-if #'(lambda (b) (not (is-connected-up-to self b))) (collect-loop-boxes (container self)))))) (if loopboxes (mapc 'box-init-iterator-value loopboxes) (om-beep-msg "Warning: ITERATE box used without iterator in patch ~A !!" (name (container self)))) (unwind-protect (progn (setf (n-iter (reference self)) 0) (setf *ev-once-context* self) (push-let-context) (let* ((iterators-code (apply 'append (mapcar 'gen-loop-code-for-eval loopboxes))) (update-iterators-value-code (apply 'append (mapcar #'(lambda (b) (gen-loop-iterator-update-code (reference b))) loopboxes))) (loop-code `(loop ,.iterators-code ,.update-iterators-value-code do (setf (n-iter ,(reference self)) (1+ (n-iter ,(reference self)))) ; do (om-print (n-iter ,(reference self)) "LOOP") collect ,(if (= 1 (length (inputs self))) `(omNG-box-value ,(car (inputs self))) `(loop for inp in ',(inputs self) collect (omNG-box-value inp))) ))) (pop-let-context) ;;; (pprint loop-code) (terpri) (when iterators-code (eval loop-code)) )) (setf *ev-once-context* old-context) (clear-ev-once (container self))) )) (defun gen-loop-declarations (let-list) (loop for item in let-list append `(with ,(car item) = ,(cadr item)))) (defmethod gen-code ((self OMPatchIteratorBox) &optional args) (let ((loopboxes (sort-boxes (remove-if #'(lambda (b) (not (is-connected-up-to self b))) (collect-loop-boxes (container self)))))) ;(push-let-context) (unwind-protect (if loopboxes (progn ;;; no eval-once (setf *freeze-eval-once-mechanism* t) (push-let-context) (let ((iterators-code (apply 'append (mapcar 'gen-loop-code-for-compile loopboxes))) (declarations-code (gen-loop-declarations (output-current-let-context)))) (pop-let-context) (setf *freeze-eval-once-mechanism* nil) (push-let-context) (unwind-protect (let ((loop-code (loop for inp in (inputs self) collect (gen-code inp)))) (list `(loop ,.declarations-code ,.iterators-code do (let* ,(output-current-let-context) ,.loop-code)) )) (pop-let-context)) )) ;;; else: no loop boxes (om-print-format "Warning: ITERATE box used without iterator in patch ~A !!" (list (name (container self)))) ) ;;; protect cleanup ;(pop-let-context) ) ))

Common Lisp

.lisp

cac-t-u-s/om-sharp

GPL-3.0

9/19/2024, 11:25:22 AM (Europe/Amsterdam)

bf42f13330c299cad85c78dad2d4b02561cf25d7f3fb943a594f73b1a9c322d3

connection.lisp

cac-t-u-s_om-sharp/src/visual-language/patch/connection.lisp

;============================================================================ ; om#: visual programming language for computer-assisted music composition ;============================================================================ ; ; This program is free software. For information on usage ; and redistribution, see the "LICENSE" file in this distribution. ; ; This program 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. ; ;============================================================================ ; File author: J. Bresson ;============================================================================ ;;;============================= ; CONNECTIONS ;;;============================= (in-package :om) (defclass OMConnection (OMVPObject) ((from :initarg :from :accessor from :initform nil) (to :initarg :to :accessor to :initform nil) (points :accessor points :initarg :points :initform nil) (modif :accessor modif :initarg :modif :initform nil) (style :accessor style :initarg :style :initform nil) (color :accessor color :initarg :color :initform nil) (seleted :accessor selected :initarg :selected :initform nil) (graphic-connection :initform nil :accessor graphic-connection))) (add-preference-section :appearance "Connections" "Default values for connections with unspecified or disabled attributes") (add-preference :appearance :connection-color "Color" :color (om-def-color :dark-gray)) (add-preference :appearance :connection-style "Style" '(:square :rounded :curved :curved-2 :line) :rounded) (defmethod get-properties-list ((self OMConnection)) '(("Appearance" ;;; category (:color "Color" :color-or-nil color (:appearance :connection-color)) ;;; id text type dafault (:style "Style" (:square :rounded :curved :curved-2 :line :default) style (:appearance :connection-style))) ("Execution" ;;; category (:reactive "Reactive (r)" :bool reactive)))) (defmethod consolidate-appearance ((self OMConnection)) (set-property self :color (make-color-or-nil :t-or-nil t :color (connection-draw-color self))) (set-property self :style (connection-draw-style self))) (defmethod object-name-in-inspector ((self OMConnection)) "CONNECTION") (defmethod connection-draw-style ((c OMConnection)) (or (style c) (get-pref-value :appearance :connection-style))) (defmethod connection-draw-color ((c OMConnection)) (if (color-? (color c)) (color-color (color c)) (get-pref-value :appearance :connection-color))) ;;; called in the properties management / inspector (defmethod object-accept-transparency ((self OMConnection)) nil) (defmethod omng-make-new-connection ((from box-output) (to box-input) &optional args) (if (recursive-connection-p (box from) (box to)) (om-beep-msg "cycles not permitted!") (apply 'make-instance (append (list 'omconnection :from from :to to) args)))) (defmethod set-graphic-connection ((c OMConnection)) (when (and (area (from c)) (area (to c))) (update-points c) (setf (graphic-connection c) (make-instance 'graphic-connection :object c :draw-points (make-graphic-points c nil))) )) (defmethod add-connection-in-view ((self om-view) (c OMConnection)) (set-graphic-connection c) (setf (view (graphic-connection c)) self) c) (defmethod omng-connect ((c OMConnection)) (if (connections (to c)) (om-beep-msg "Can't connect a box input several time! You should not be here!") (setf (connections (from c)) (append (connections (from c)) (list c)) (connections (to c)) (append (connections (to c)) (list c))) )) (defmethod omng-unconnect ((c OMConnection)) (setf (connections (from c)) (remove c (connections (from c)))) (setf (connections (to c)) (remove c (connections (to c))))) (defmethod initialize-size ((c OMConnection)) (setf (modif c) (list 0 0)) (update-points c) (update-graphic-connection c)) ;;; called when the boxes are moved etc. #| (defmethod update-points ((c OMConnection)) (when (and (area (from c)) (area (to c))) ;; the two extremities have been created already (let* ((p1 (io-position-in-patch (area (from c)))) (p2 (io-position-in-patch (area (to c)))) (+x (or (car (modif c)) 0)) (+y (or (cadr (modif c)) 0))) (setf (points c) (if (> (om-point-y p2) (om-point-y p1)) (let ((mid-y (/ (+ (om-point-y p1) (om-point-y p2)) 2))) (list p1 (om-make-point (om-point-x p1) (+ mid-y +y)) (om-make-point (om-point-x p2) (+ mid-y +y)) p2)) (let ((dy 8) (mid-x (/ (+ (om-point-x p1) (om-point-x p2)) 2))) (list p1 (om-make-point (om-point-x p1) (+ (om-point-y p1) dy)) (om-make-point (+ +x mid-x) (+ (om-point-y p1) dy)) (om-make-point (+ +x mid-x) (- (om-point-y p2) dy)) (om-make-point (om-point-x p2) (- (om-point-y p2) dy)) p2) )) ) ))) |# (defmethod update-points ((c OMConnection)) ;; the two extremities have been created and ppositioned already (when (and (area (from c)) (area (to c))) (let* ((p1 (io-position-in-patch (area (from c)))) (p2 (io-position-in-patch (area (to c)))) (y1 (om-point-y p1)) (y2 (om-point-y p2)) (+x (or (car (modif c)) 0)) (+y (or (cadr (modif c)) 0)) (frombox-x (box-x (box (from c)))) (tobox-x (box-x (box (to c)))) (tobox-width (or (box-w (box (to c))) (w (frame (box (to c)))))) ;;; sometimes box-w is nil (frombox-width (or (box-w (box (from c))) (w (frame (box (from c)))))) ;;; sometimes box-w is nil ;;; decide when to curve the connection => not if the two boxes overlap in x (threshold (if (or (>= frombox-x (+ tobox-x tobox-width)) (>= tobox-x (+ frombox-x frombox-width))) 16 4))) (setf (points c) (if (> y2 (+ y1 threshold)) (list (omp 0 0) (omp 0 (+ 0.5 +y)) (omp 1.0 (+ 0.5 +y)) (omp 1.0 1.0)) (list (omp 0 0) (omp 0 8) (omp (+ +x 0.5) 8) (omp (+ +x 0.5) (round (- y2 y1 8))) (omp 1.0 (round (- y2 y1 8))) (omp 1.0 1.0)) )) ))) (defmethod get-out-connections ((self OMBox)) (loop for out in (outputs self) append (connections out))) (defmethod get-in-connections ((self OMBox)) (loop for inp in (inputs self) append (connections inp))) (defmethod get-box-connections ((self OMBox)) (append (get-in-connections self) (get-out-connections self))) (defmethod get-out-connected-boxes ((self OMBox)) (remove-duplicates (remove nil (loop for out in (outputs self) append (loop for c in (connections out) collect (box (to c))))))) (defmethod get-in-connected-boxes ((self OMBox)) (remove-duplicates (remove nil (loop for in in (inputs self) append (loop for c in (connections in) collect (box (from c))))))) (defmethod get-all-in-connected-boxes ((self OMBox)) (remove-duplicates (loop for box in (get-in-connected-boxes self) append (cons box (get-all-in-connected-boxes box))))) ;;; return all sequences of boxes up from a given box (defmethod get-all-branches ((self OMBox) &optional up-to-box) (let ((connections (loop for input in (inputs self) append (connections input))) ; in principle there can be only one! (leaf (if up-to-box (equal self up-to-box) (null connections)))) (if leaf (list (list self)) ;;; we also enter here id up-to-box is non-null and there is no connections ;;; -> cancel the branch (remove nil (loop for c in connections append (loop for branch in (get-all-branches (box (from c)) up-to-box) collect (cons self branch)))) ))) (defmethod recursive-connection-p ((from OMBox) (to OMBox)) "Check if there is a cyclic connection" (let (rep) (loop for cb in (get-out-connected-boxes to) while (not rep) do (if (equal cb from) (setf rep t) (setf rep (recursive-connection-p from cb)))) rep)) ;;; checks if box2 is up-connected to box1 (defmethod is-connected-up-to ((box1 OMBox) (box2 OMBox)) (let ((up-boxes (get-in-connected-boxes box1))) (or (find box2 up-boxes) (let ((rep nil)) (loop for cb in up-boxes while (not rep) do (setf rep (is-connected-up-to cb box2))) rep)))) (defmethod boxes-connected-p ((box1 OMBox) (box2 OMBox)) (or (is-connected-up-to box1 box2) (is-connected-up-to box2 box1))) (defmethod save-connections-from-boxes (box-list) (loop for box in box-list for b = 0 then (+ b 1) append (loop for out-c in (get-out-connections box) for c = 0 then (+ c 1) when (find (box (to out-c)) box-list) collect (append `(:connection (:from (:box ,b :out ,(position (from out-c) (outputs box)))) ;; (box out) (:to (:box ,(position (box (to out-c)) box-list) :in ,(position (to out-c) (inputs (box (to out-c)))))) ;;; (box in) ) (when (or (color out-c) (style out-c) (modif out-c)) `((:attributes (:color ,(omng-save (color out-c)) :style ,(style out-c) :modif ,(modif out-c))) )) ) ))) ;;; SOME BOXES MAY GENERATE THE IN/OUTPUTS ON REQUEST ;;; e.g. at loading undefined/lost-reference boxes (defmethod get-nth-output ((self OMBox) n) (and n (nth n (outputs self)))) (defmethod get-nth-input ((self OMBox) n) (and n (nth n (inputs self)))) ;;; some boxes can greate artificially some temporary in/outs (used at loading self-contaiend, recursive abstractions) (defmethod gen-temp-nth-input ((self t) n) nil) (defmethod gen-temp-nth-output ((self t) n) nil) (defmethod restore-connections-to-boxes (connections box-list) (remove nil (loop for c in connections collect (let* ((connection-info (cdr c)) (b1 (find-value-in-kv-list connection-info :from)) ;;; actually a list (:box box-num :out out-num) (b2 (find-value-in-kv-list connection-info :to)) ;;; actually a list (:box box-num :in in-num) (box-from (and (getf b1 :box) (nth (getf b1 :box) box-list))) (box-to (and (getf b2 :box) (nth (getf b2 :box) box-list))) (out (when box-from (get-nth-output box-from (getf b1 :out)))) (in (when box-to (get-nth-input box-to (getf b2 :in)))) (attributes (find-value-in-kv-list connection-info :attributes))) (cond ((and out in) (omng-make-new-connection out in (list :color (omng-load (getf attributes :color)) :style (getf attributes :style) :modif (getf attributes :modif)))) ((null box-from) (om-print-format "Connection could not be restored: missing box #~D" (list (getf b1 :box)) "WARNING") NIL) ((null box-to) (om-print-format "Connection could not be restored: missing box #~D" (list (getf b2 :box)) "WARNING") NIL) ((null out) ;;; two boxes are here but no nth output (let ((temp-out (gen-temp-nth-output box-from (getf b1 :out)))) (if temp-out (progn (om-print-dbg "Creating temporary output ~D for ~A: ~A" (list (getf b1 :out) (name box-from) temp-out) "Import Warning") (omng-make-new-connection temp-out in (list :color (omng-load (getf attributes :color)) :style (getf attributes :style) :modif (getf attributes :modif))) ) (progn (om-print-format "Connection could not be restored normally from ~A (~D) [NO OUTPUT] to ~A (~D)" (list (name box-from) (getf b1 :out) (name box-to) (getf b2 :in)) "Import Warning") NIL)) )) ((null in) ;;; two boxes are here but no nth input (let ((temp-in (and (getf b2 :in) (gen-temp-nth-input box-to (getf b2 :in))))) (if temp-in (progn (om-print-dbg "Creating temporary input ~D for ~A: ~A." (list (getf b2 :in) (name box-to) temp-in) "Import Warning") (omng-make-new-connection out temp-in (list :color (omng-load (getf attributes :color)) :style (getf attributes :style) :modif (getf attributes :modif)))) (progn (om-print-format "Connection could not be restored normally from ~A (~D) to ~A (~D) [NO INPUT]" (list (name box-from) (getf b1 :out) (name box-to) (getf b2 :in)) "Import Warning") NIL)) )) (t ;;; no way (this case should never happen...) (om-print-format "Connection could not be restored from ~A (~D) to ~A (~D)" (list (name box-from) (getf b1 :out) (name box-to) (getf b2 :in)) "Import Warning") NIL)) ) ))) (defmethod adopt-connection ((self box-input) (connection omconnection)) (let ((previous (to connection))) (setf (connections previous) (remove connection (connections previous))) (setf (to connection) self)) connection) (defmethod adopt-connection ((self box-output) (connection omconnection)) (let ((previous (from connection))) (setf (connections previous) (remove connection (connections previous))) (setf (from connection) self)) connection) ;;; dx and dy are ratios (defmethod modif-connection ((c OMConnection) dx dy) (unless (modif c) (setf (modif c) (list 0 0))) (cond ((= 4 (length (points c))) ;; 'vertical' connection : consider only dy (setf (cadr (modif c)) (max -0.45 (min 0.45 (+ (cadr (modif c)) dy))))) ((= 6 (length (points c))) ;; 'horizontal' connection : consider only dx (setf (car (modif c)) (max -0.45 (min 0.45 (+ (car (modif c)) dx))))) (t nil)) (update-points c) (update-graphic-connection c)) ;;; mouse drag: dx and dy are pixels (defmethod drag-connection ((c OMConnection) dx dy) (let* ((from-p (om-add-points (get-position (area (from c))) (om-view-position (frame (area (from c)))))) (to-p (om-add-points (get-position (area (to c))) (om-view-position (frame (area (to c)))))) (x1 (om-point-x from-p)) (x2 (om-point-x to-p)) (y1 (om-point-y from-p)) (y2 (om-point-y to-p)) (dxx (if (= x1 x2) 0 (/ dx (- x2 x1)))) (dyy (if (= y1 y2) 0 (/ dy (- y2 y1))))) (when (or dxx dyy) (modif-connection c dxx dyy)) )) ;;; called from editor keys (dx / dx = 1 or 10) (defmethod move-box ((c OMConnection) dx dy) (drag-connection c dx dy)) ;;;============================= ;;; GRAPHIC CONNECTION ;;;============================= ;;; graphic connections are "fake" frames (defclass graphic-connection (OMFrame) ((view :accessor view :initarg :view :initform nil) ;;; not used / never accessed ? (cf. inspector) (draw-points :accessor draw-points :initarg :draw-points :initform nil))) (defmethod select-box ((self OMConnection) selected) (unless (equal (selected self) selected) (setf (selected self) selected) (when (graphic-connection self) (om-invalidate-view (graphic-connection self)) (let ((ed (editor (om-view-window (graphic-connection self))))) (when ed (update-inspector-for-editor ed)) )))) (defmethod get-draw-points ((self OMConnection)) (and (graphic-connection self) (draw-points (graphic-connection self)))) ;;; called when graphics are recalculated (defmethod make-graphic-points ((c omconnection) view) (let* ((p1 (io-position-in-patch (area (from c)))) (p2 (io-position-in-patch (area (to c)))) (diff-points (om-subtract-points p2 p1)) (gpts (mapcar #'(lambda (p) (om-add-points p1 (om-make-point (if (integerp (om-point-x p)) (om-point-x p) (* (om-point-x p) (om-point-x diff-points))) (if (integerp (om-point-y p)) (om-point-y p) (* (om-point-y p) (om-point-y diff-points))) ))) (points c)))) (let ((style (connection-draw-style c))) (case style (:rounded (get-rounded-pts gpts 4)) (:curved (get-spline-pts gpts 40)) (:curved-2 (get-ramped-sine-pts gpts 40)) (:line (list (car gpts) (car (last gpts)))) (otherwise gpts)) ))) ;;; point generation for rounden connections (defun get-rounded-pts (pts corner) (append (list (car pts)) (loop for p on pts while (caddr p) append (let ((x1 (om-point-x (car p))) (y1 (om-point-y (car p))) (x2 (om-point-x (cadr p))) (y2 (om-point-y (cadr p))) (x3 (om-point-x (caddr p))) (y3 (om-point-y (caddr p))) p1x p1y p2x p2y) (if (= x1 x2) ;; first segment is vertical (let ((direction (- x3 x2)) (cc (min corner (/ (abs (- y1 y2)) 2) (/ (abs (- x3 x2)) 2)))) (cond ((plusp direction) ;; second segment turns right (setf p1x x2 p1y (+ y2 (if (> y1 y2) cc (- cc))) p2x (+ x2 cc) p2y y2)) ((minusp direction) ;; second segment turns left (setf p1x x2 p1y (+ y2 (if (> y1 y2) cc (- cc))) p2x (+ x2 (- cc)) p2y y2)) ) (when (and p1x p1y p2x p2y) (list (omp p1x p1y) (omp (+ p1x (* 0.25 (- p2x p1x))) (+ p1y (* 0.5 (- p2y p1y)))) (omp (+ p1x (* 0.5 (- p2x p1x))) (+ p1y (* 0.75 (- p2y p1y)))) (omp p2x p2y)) )) ;;; first segment is horizontal (let ((direction (- y3 y2)) (cc (min corner (/ (abs (- x1 x2)) 2) (/ (abs (- y3 y2)) 2)))) (cond ((plusp direction) ;; second segment goes down (setf p1x (+ x2 (if (plusp (- x2 x1)) (- cc) cc)) p1y y2 p2x x2 p2y (+ y2 cc))) ((minusp direction) ;; second segment goes down (setf p1x (+ x2 (if (plusp (- x2 x1)) (- cc) cc)) p1y y2 p2x x2 p2y (+ y2 (- cc)))) ) (when (and p1x p1y p2x p2y) (list (omp p1x p1y) (omp (+ p1x (* 0.5 (- p2x p1x))) (+ p1y (* 0.25 (- p2y p1y)))) (omp (+ p1x (* 0.75 (- p2x p1x))) (+ p1y (* 0.5 (- p2y p1y)))) (omp p2x p2y)) )) ) ;; end if ) ;; end let ) ;; end loop ;;; last element to append... (last pts)) ) ;;; point generation for curved connections (defun get-spline-pts (pts resolution &optional (order 4)) (mapcar #'(lambda (p) (om-make-point (car p) (cadr p))) (spline (mapcar #'(lambda (omp) (list (om-point-x omp) (om-point-y omp))) pts) order ; (min 3 (- (length gpts) 1)) resolution))) ;;; another curved connection version by G. Holbrook (defun get-ramped-sine-pts (pts resolution) (let ((x1 (om-point-x (car pts))) (y1 (om-point-y (car pts))) (x2 (om-point-x (car (last pts)))) (y2 (om-point-y (car (last pts))))) (let* ((width (abs (- x2 x1))) ;calculate 'mirrored' y2 (a clipped linear function) (anti-y2 (max (+ (* -1/3 y2) (* 4/3 (+ y1 (* 1/2 width)))) y2) )) (flet ((scale (x minout maxout minin maxin) (if (= maxin minin) minin (+ minout (/ (* (- x minin) (- maxout minout)) (- maxin minin)))))) (loop for k from 0 to resolution for rad = (scale k -1.57 1.57 0 resolution) for ramp = (* (* (+ (sin (scale k -1.57 1.57 0 resolution)) 1) 0.5) ;; 0 to 1 half-sine-curve (- anti-y2 y2)) ;; positive number collect (omp (scale (sin rad) x1 x2 -1 1) (- (scale k y1 anti-y2 0 resolution) ramp ))) )))) (defmethod update-graphic-connection ((c omconnection)) (when (graphic-connection c) (setf (draw-points (graphic-connection c)) (make-graphic-points c (view (graphic-connection c)))) (update-connection-display c (view (graphic-connection c))) )) (defmethod om-draw-contents ((self graphic-connection)) (let ((line-w (if (selected (object self)) 2.5 1.5)) (reactive (and (reactive (from (object self))) (reactive (to (object self))))) (color (connection-draw-color (object self)))) (when reactive (om-draw (draw-points self) :color (om-make-color-alpha (om-def-color :dark-red) (if (equal (state self) :disabled) 0.3 1)) :line (1+ line-w))) (om-draw (draw-points self) :color (om-make-color-alpha color (if (equal (state self) :disabled) 0.3 1)) :line line-w) ;(when (and (selected (object self)) (not (equal :spline (style (object self))))) ; (mapcar ; #'(lambda (p) (om-draw-circle (om-point-x p) (om-point-y p) 3 :fill t)) ; (draw-points self))) )) (defmethod x ((self graphic-connection)) 0) (defmethod y ((self graphic-connection)) 0) (defmethod graphic-area ((c OMConnection)) (and (graphic-connection c) (graphic-area (graphic-connection c)))) (defmethod graphic-area ((c graphic-connection)) (list (- (apply 'min (mapcar 'om-point-x (draw-points c))) 10) (- (apply 'min (mapcar 'om-point-y (draw-points c))) 10) (+ (apply 'max (mapcar 'om-point-x (draw-points c))) 10) (+ (apply 'max (mapcar 'om-point-y (draw-points c))) 10) )) (defmethod get-update-frame ((self OMConnection)) (graphic-connection self)) ;;; called after an edit from the inspector (defmethod update-after-prop-edit (view (object omconnection)) (update-graphic-connection object) (om-invalidate-view (graphic-connection object))) (defmethod om-invalidate-view ((self graphic-connection)) (when (view self) (apply 'om-invalidate-area (cons (view self) (graphic-area self))))) (defmethod om-view-window ((self graphic-connection)) (and (view self) (om-view-window (view self)))) (defmethod update-connection-display ((c OMConnection) view) (when view (apply 'om-invalidate-area (cons view (graphic-area (graphic-connection c)))))) ;;;============================= ;;; SELECTION/EDITION ;;;============================= (defmethod point-in-connection (point (c OMConnection)) (and (graphic-connection c) (point-in-connection point (graphic-connection c)))) (defmethod point-in-connection (point (c graphic-connection)) (let ((in nil)) (loop for p on (draw-points c) while (and (not in) (cdr p)) do (setf in (om-point-in-line-p point (car p) (cadr p) 4))) in)) ;;;============================= ;;;PROPERTIES EDITION (INSPECTOR) ;;;============================= (defmethod is-reactive ((self OMConnection)) (and (reactive (from self)) (reactive (to self)))) (defmethod set-reactive ((self OMConnection) val) (setf (reactive (from self)) val (reactive (to self)) val)) ;; REACTIVITY (defmethod set-reactive-mode ((self OMConnection)) (set-reactive self (not (is-reactive self))) (om-invalidate-view (graphic-connection self))) ;;; from inspector ;;; reactive is not a "real" property (defmethod valid-property-p ((object OMConnection) (prop-id (eql :reactive))) nil) (defmethod set-property ((object OMConnection) (prop-id (eql :reactive)) val) (set-reactive object val)) (defmethod get-property ((object OMConnection) (prop-id (eql :reactive)) &key (warn t)) (declare (ignore warn)) (is-reactive object)) ;;;============================= ;;; CONNECTION WITH THE INSPECTOR WINDOW ;;;============================= (defmethod set-reactive-mode :after ((self omconnection)) (update-inspector-for-object self))

Common Lisp

.lisp

cac-t-u-s/om-sharp

GPL-3.0

9/19/2024, 11:25:22 AM (Europe/Amsterdam)

61f79e1f46bf49e34572d122475ba0afd7397d818e5e14982f6ab92a9d11fe8e

boxobject.lisp

cac-t-u-s_om-sharp/src/visual-language/patch/boxobject.lisp

;============================================================================ ; om#: visual programming language for computer-assisted music composition ;============================================================================ ; ; This program is free software. For information on usage ; and redistribution, see the "LICENSE" file in this distribution. ; ; This program 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. ; ;============================================================================ ; File author: J. Bresson ;============================================================================ ;;;==================================================== ;;; OBJECT/DATA BOXES: FACTORY, SLOTS, INSTANCE ;;;==================================================== ;;; Rules for object boxes: ;;; - The main slots of the box are the direct slots that have declared initargs ;;; - Additional (keyword) slots are declared with 'additional-class-attributes' ;;; - They are matched to a slot accessor if this slot is declared with initarg (in one of the class' superclasses) (in-package :om) ;;=========================================== ; ABSTRACT SUPERCLASS ;;=========================================== ;;; for boxeditcall ans slotsbox (defclass OMBoxRelatedWClass (OMBoxCall) () (:documentation "Boxes with a class as reference") (:metaclass omstandardclass)) (defmethod get-icon-id ((self OMBoxRelatedWClass)) 'icon-class) ;;; for the moment we do not allow object boxes in lambda mode (defmethod valid-property-p ((self OMBoxRelatedWClass) (prop-id (eql :lambda))) t) (defmethod eval-modes-for-box ((self OMBoxRelatedWClass)) '(nil :reference :box)) (defmethod box-def-self-in ((self t)) NIL) (defmethod create-box-inputs ((self OMBoxRelatedWClass)) (let ((class (find-class (reference self) nil))) (when class (cons (make-instance 'box-input :name "SELF" :box self :reference :self :value (box-def-self-in (reference self)) :doc-string "Connect here to create a new instance by copy") (mapcar #'(lambda (slot) (make-instance 'box-input :name (string (slot-name slot)) :reference (slot-name slot) :box self :value (valued-val (slot-initform slot)) :doc-string (apply 'concatenate (cons 'string (append (unless (equal t (slot-type slot)) (list "[" (string-downcase (slot-type slot)) "] ")) (list (slot-doc slot))) ) ))) (remove-if-not 'slot-initargs (class-direct-instance-slots class))) ;;; direct ? ) ))) (defmethod create-box-outputs ((self OMBoxRelatedWClass)) (let ((class (find-class (reference self) nil))) (when class (cons (make-instance 'box-output :name "SELF" :reference :self :box self :doc-string (format nil "Instance of class ~A" (class-name class))) (mapcar #'(lambda (slot) (make-instance 'box-output :name (string (slot-name slot)) :reference (slot-name slot) :box self :doc-string (or (slot-doc slot) nil))) (remove-if-not 'slot-initargs (class-direct-instance-slots class))) ;;; direct ? )))) ;;; ADDITIONAL CLASS AND BOX/EDITOR ATTRIBUTES CAN BE ADDED AS OPTIONAL/KEYWORDS ;; will appear as a keyword input (must be a valid slot) (defmethod additional-class-attributes ((self t)) nil) (defmethod allow-more-optionals ((self OMBoxRelatedWClass)) t) ;;; box attributes can be just a name, or ;;; (name doc menu) (defmethod additional-box-attributes ((self t)) nil) (defmethod box-attributes-names ((attributes list)) (mapcar #'(lambda (attr) (if (listp attr) (car attr) attr)) attributes)) (defmethod additional-box-attributes-names ((self OMBoxRelatedWClass)) (box-attributes-names (additional-box-attributes (get-box-value self)))) (defmethod get-all-keywords ((self OMBoxRelatedWClass)) ;; this function can be called when the value is not yet initialised in the box (let ((val (or (and (null (lambda-state self)) (get-box-value self)) (make-instance (reference self))))) (remove nil (list (additional-class-attributes val) (box-attributes-names (additional-box-attributes val)) )) )) (defun make-unique-name (symbol-base name-list) (let ((pack (symbol-package symbol-base)) (name (symbol-name symbol-base))) (if (find name name-list :test 'string-equal) (let () (loop while (find name name-list :test 'string-equal) for i = 2 then (+ i 1) do (setf name (string+ (symbol-name symbol-base) "_" (number-to-string i)))) (intern name pack)) symbol-base) )) (defmethod next-keyword-input ((self OMBoxRelatedWClass)) (let ((keywordlist (apply 'append (get-all-keywords self))) (usedkeywords (mapcar #'(lambda (in) (name in)) (get-keyword-inputs self)))) (if keywordlist (or (find-if-not #'(lambda (elt) (member elt usedkeywords :test 'string-equal)) keywordlist :key 'string) (and (find (box-free-keyword-name self) keywordlist) (make-unique-name (box-free-keyword-name self) usedkeywords)) (values nil "All keywords are already used..")) (values nil (string+ "No keyword for box '" (name self) "'."))) )) (defmethod add-keyword-input ((self OMBoxRelatedWClass) &key key value doc reactive) (declare (ignore value doc reactive)) (call-next-method) (let ((name (string-downcase key))) (set-box-outputs self (append (outputs self) (list (make-instance 'box-keyword-output :name name :box self :doc-string (get-input-doc self name))))) )) (defmethod update-output-from-new-in ((box OMBoxRelatedWClass) name in) (let ((out (find name (outputs box) :key 'name :test 'string-equal))) (when out (setf (name out) (name in) (doc-string out) (get-input-doc box (name in))) ))) (defmethod remove-one-keyword-input ((self OMBoxRelatedWClass)) (when (call-next-method) (remove-one-output self (car (last (outputs self)))))) ;;;=============================== ;;; RELATION TO REFERENCE CLASS ;;; (WHEN THE CLASS IS AN OMCLASS) ;;;=============================== (defmethod om-copy ((self OMBoxRelatedWClass)) (let* ((newbox (call-next-method)) (class (find-class (reference newbox) nil))) (when (omclass-p class) (retain-reference class newbox)) newbox)) (defmethod omng-delete ((box OMBoxRelatedWClass)) (call-next-method) (let ((class (find-class (reference box) nil))) (when (omclass-p class) (release-reference class box))) t) ;;;=============================== ;;; EVALUATION ;;;=============================== (defmethod objFromObjs ((model t) (target t)) (if (or (subtypep (type-of target) (type-of model)) (subtypep (type-of model) (type-of target))) (clone-object model target) (om-beep-msg "No conversion method was found from ~A to ~A" (type-of model) (type-of target)) )) ; don't mess with packages: send interned symbols to these functions ;(defun set-slot-val (obj slot-name value) ; (eval `(setf (,(intern-pack slot-name (symbol-package (type-of obj))) ,obj) ',value))) (defmethod set-slot-val (obj slot-name value) (eval `(setf (,slot-name ,obj) ',value))) (defmethod set-slot-val (obj (slot-name string) value) (let ((slot (find slot-name (class-slots (class-of obj)) :key #'(lambda (slot) (string (slot-name slot))) :test 'string-equal))) (when slot (set-slot-val obj (slot-name slot) value)))) ;(defmethod get-slot-val (obj slot-name) ; (eval `(,(intern-pack slot-name (symbol-package (type-of obj))) ,obj))) (defmethod get-slot-val (obj slot-name) (eval `(,slot-name ,obj))) (defmethod get-slot-val (obj (slot-name string)) (let ((slot (find slot-name (class-slots (class-of obj)) :key #'(lambda (slot) (string (slot-name slot))) :test 'string-equal))) (when slot (get-slot-val obj (slot-name slot))))) (defun set-value-slots (value args) (mapcar #'(lambda (item) (set-slot-val value (car item) (cadr item))) args)) ;;; called after slots are set (including in OM) ;;; or when a new slot is set (e.g. slot box, property, etc.) ;;; <initargs> = NIL for save/load/copy OR in the init value of a box ;;; <initargs> = all initargs in MAKE-VALUE / list incl. connected initargs MAKE-VALUE-FROM-MODEL (defmethod om-init-instance ((self t) &optional initargs) self) (defmethod update-after-eval ((self OMBoxRelatedWClass)) nil) (defmethod get-connected-args ((self OMBoxRelatedWClass) &optional (accessor #'omng-box-value)) (remove nil (mapcar #'(lambda (input) (when (connections input) (list (intern-k (name input)) (funcall accessor input)))) (cdr (inputs self))))) (defmethod get-all-args ((self OMBoxRelatedWClass) &optional (accessor #'omng-box-value)) (mapcar #'(lambda (input) (list (intern-k (name input)) (funcall accessor input))) (cdr (inputs self)))) ;;; Called by the main box evaluation procedure ;;; <initargs> are all the input values (connected or not) (defun make-value (classname initargs) (let* ((class-slots (class-instance-slots (find-class classname))) (class-initargs (remove nil (mapcar 'slot-initargs class-slots))) (class-slots-names (mapcar 'slot-name class-slots)) ;;; the regular class initargs (supplied-initargs (remove-if #'(lambda (item) (not (find item class-initargs :test 'find))) initargs :key 'car)) ;;; not initargs but valid slots (supplied-other-args (loop for arg in initargs when (and (find (symbol-name (car arg)) class-slots-names :key 'symbol-name :test 'string-equal) (not (member (car arg) supplied-initargs :key 'car))) collect (list (symbol-name (car arg)) (cadr arg))))) (om-init-instance (let ((obj (apply 'make-instance (cons classname (reduce 'append supplied-initargs))))) (set-value-slots obj supplied-other-args) obj) initargs) )) ;;; SPECIAL FOR BOXEDITCALL: ;;; If the first input is connected the value is built by copying a prototype instance (<model>) ;;; <args> are only the connected input values (defun make-value-from-model (type model initargs) (let* ((target (make-instance type)) (rep (if (equal (type-of model) (type-of target)) (om-copy model) (objFromObjs model target))) (class-slots-names (mapcar 'slot-name (class-instance-slots (find-class type)))) (set-slot-args (loop for initarg in initargs when (find (symbol-name (car initarg)) class-slots-names :key 'symbol-name :test 'string-equal) collect (list (symbol-name (car initarg)) (cadr initarg))))) (if rep (progn (set-value-slots rep set-slot-args) (om-init-instance rep (or initargs '(nil))) ;;; we want to pass a non-nil ['(NIL) and not NIL] value in order to signal evaluation mode to om-init-instance ) (progn (om-beep-msg "Error creating a ~A from ~A" type model) (abort-eval))) )) (defmethod prepare-obj-for-request ((object t) (box OMBoxRelatedWClass)) object) ;;; NEEDS TO BE REWORKED/SIMPLIFIED ;;; IN PRINCIPLE THE CASE LAMBDA NEVER HAPPENS (defmethod rep-editor ((box OMBoxRelatedWClass) num) (if (= num 0) (car (value box)) (cond ;;; GENERAL CASE ((null (lambda-state box)) (let* ((obj (prepare-obj-for-request (get-box-value box) box)) (slot (name (nth num (outputs box))))) (cond ((find slot (class-instance-slots (find-class (type-of obj))) :test 'string-equal :key #'(lambda (slot) (symbol-name (slot-name slot)))) (get-slot-val (car (value box)) slot)) ((find (intern-k slot) (additional-box-attributes-names box)) (get-edit-param box (intern-k slot))) (t nil)))) ;;; LAMBDA ((equal (lambda-state box) :lambda) (let ((new-arg-list (function-arg-list (car (value box))))) ; (loop for n from 1 to (length (function-lambda-list (car (value box)))) collect (gensym)))) (eval `#'(lambda ,new-arg-list (let ((value (funcall ,(car (value box)) ,.new-arg-list))) (get-slot-val value ,(name (nth num (outputs box))))))))) ;;; OTHER CASES (t (car (value box)))) )) ;;=========================================== ;; THE MAIN OBJECT BOX (FACTORY) ;;=========================================== (defclass OMBoxEditCall (OMBoxRelatedWClass ObjectWithEditor object-with-edit-params) ((play-state :initform nil :accessor play-state)) (:metaclass omstandardclass)) (defmethod special-box-type ((class-name t)) nil) (defmethod default-size ((self OMBoxEditCall)) (om-make-point 80 50)) (defmethod maximum-size ((self OMBoxEditCall)) nil) (defmethod minimum-size ((self OMBoxEditCall)) (om-make-point (+ 10 (max 60 (* (length (inputs self)) 10) (* (box-n-outs self) 10))) 40)) (defmethod get-box-class ((self standard-class)) (let ((classes (clos::class-precedence-list self))) (or (loop for c in classes when (special-box-type (class-name c)) return (special-box-type (class-name c))) 'OMBoxEditCall))) (defmethod editor-name-for-window-title ((self OMBoxEditCall)) (object-name-for-window-title (car (value self)))) (defmethod object-name-for-window-title ((self t)) (get-object-type-name self)) (defmethod extra-window-title-info ((self OMBoxEditCall)) (extra-window-title-info (car (value self)))) (defmethod def-reactive ((self OMBoxEditCall) key) (if (find key (additional-box-attributes-names self)) T NIL)) ;;; NOT ! called when properties are changed in the inspector (defmethod om-init-instance ((self omboxeditcall) &optional initargs) (let ((name (find-value-in-kv-list initargs :name))) (when (and name (editor self)) (report-modifications (editor self))) self)) (defmethod omng-delete ((box OMBoxEditCall)) (call-next-method) (when (editor box) (om-close-window (editor-window box)) (when (editor box) ;;; in principle the window-close callback will have closed the editor and set it to NIL ;;; but for instance not if the window is not a special om# window (e.g. external app or library...) (editor-close (editor box)))) (box-player-stop box) (omng-delete (get-box-value box)) t) (defmethod get-input-def-value ((self OMBoxEditCall) name) (let ((slot (find name (class-instance-slots (find-class (reference self) nil)) :key 'slot-name))) (if slot (eval (slot-initform slot)) ;;; maybe it's the edit-params.. ? (get-default-edit-param self name)))) (defmethod get-input-doc ((self OMBoxEditCall) name) (let ((slot (find (intern name (symbol-package (reference self))) (class-instance-slots (find-class (reference self) nil)) :key 'slot-name))) (if slot (slot-doc slot) ;;; maybe it's the edit-params.. ? (let* ((val (or (and (null (lambda-state self)) (car (value self))) (make-instance (reference self)))) (pos (position (intern-k name) (additional-box-attributes val) :key 'car))) (when pos (nth 1 (nth pos (additional-box-attributes val)))))))) (defmethod class-attributes-menus ((self t)) nil) (defmethod get-input-menu ((self OMBoxEditCall) name) (let* ((val (or (and (null (lambda-state self)) (car (value self))) (make-instance (reference self)))) (found-in-class-attr (find name (class-attributes-menus val) :key #'(lambda (entry) (string (car entry))) :test 'string-equal)) (found-in-box-attr (find (intern-k name) (additional-box-attributes val) :key 'car))) (or (nth 1 found-in-class-attr) (nth 2 found-in-box-attr)))) (defmethod object-has-editor ((self t)) nil) (defmethod get-value-for-editor ((self OMBoxEditCall)) (get-box-value self)) (defmethod open-editor ((self OMBoxEditCall)) (when (object-has-editor (car (value self))) (unless (editor self) (setf (editor self) (make-instance (get-editor-class (car (value self))) :object self)) (init-editor (editor self))) (open-editor-window (editor self)))) ;;;============================= ;;; EDIT-PARAMS ;;;============================= (defmethod object-default-edition-params ((self t)) nil) (defmethod get-default-edit-param ((self OMBoxEditCall) param) (let ((val (or (car (value self)) (make-instance (reference self))))) (find-value-in-kv-list (object-default-edition-params val) param))) ;;;============================= ;;; FRAME ;;;============================= (defclass OMObjectBoxFrame (OMBoxFrame) ((box-play-time :initform nil :accessor box-play-time))) (defmethod get-box-frame-class ((self OMBoxEditCall)) 'OMObjectBoxFrame) (defmethod get-box-help ((self OMBoxEditCall)) (format nil "Object of type ~A" (string-upcase (reference self)))) (defmethod box-ed-params-properties ((self t)) nil) (defmethod editor-ed-params-properties ((self t)) nil) (defmethod get-properties-list ((self OMBoxEditCall)) (let ((properties (add-properties (call-next-method) "Appearance" (append `((:name "Name" :string name) (:display "View (m)" ,(display-modes-for-object (get-box-value self)) display) (:showname "Show name (n)" :bool show-name)) )))) (if (play-obj? (get-box-value self)) (add-properties properties "Sequencer" '((:show-markers "Show markers" :bool show-markers))) properties) )) (defmethod display-modes-for-object ((self t)) '(:text :hidden)) (defmethod set-display ((self OMBox) val) (setf (display self) val) (update-inspector-for-object self) (when (frame self) (om-invalidate-view (frame self)))) (defmethod change-display ((self OMBox)) (when (visible-property (get-properties-list self) :display) (let ((next-mode (next-in-list (display-modes-for-object (car (value self))) (display self)))) (set-display self next-mode)))) (defmethod set-box-play-time ((self OMObjectBoxFrame) time) (setf (box-play-time self) time)) (defmethod set-box-play-time ((self t) time) nil) ;;; redefine when default init value is different (defmethod initialize-box-value ((self OMBoxeditCall) &optional value) (let ((val (or value (om-init-instance (make-instance (reference self)))))) (set-name val (string-upcase (reference self))) (setf (value self) (list val)) (reset-cache-display self) (when (frame self) (om-invalidate-view (frame self))) (when (editor self) (update-to-editor (editor self) self)))) (defmethod omNG-make-new-boxcall ((reference standard-class) pos &optional init-args) (let* ((box (make-instance (get-box-class reference) ;;; when typed from the pach editor, the passed ibit-args is just a name (string) :name (if (stringp init-args) init-args nil) ; (format nil "~A" init-args) :reference (class-name reference) :icon-pos :noicon :show-name nil :display :mini-view :text-align :center)) (size (default-size box))) (setf (box-x box) (om-point-x pos) (box-y box) (om-point-y pos) (box-w box) (om-point-x size) (box-h box) (om-point-y size)) ;;; if init-args is not a string, it is considered a value for init... ;;; should actually test that this is an instance of reference (initialize-box-value box (if (not (stringp init-args)) init-args)) (setf (display box) (car (display-modes-for-object (get-box-value box)))) box)) (defmethod omNG-make-new-boxcall ((reference OMClass) pos &optional init-args) (let ((box (call-next-method))) (retain-reference reference box) box)) (defmethod om-copy ((self OMBoxEditCall)) (let ((newbox (call-next-method))) (setf (value newbox) (om-copy (value self))) newbox)) (defmethod after-copy-action ((self OMBoxEditCall)) (unless (find-if #'connections (inputs self)) (set-lock-state self :locked))) (defmethod om-view-doubleclick-handler ((self OMObjectBoxFrame) pos) (or (apply-in-area self 'click-in-area pos) (open-editor (object self)))) (defmethod update-after-prop-edit ((self OMBoxFrame) (object OMBoxEditCall)) (call-next-method) (when (editor object) (update-to-editor (editor object) object))) ;;;======================= ;;; DRAW ;;;======================= (defmethod box-draw ((self OMBoxEditCall) (frame OMBoxFrame)) (draw-value-in-frame (get-box-value self) frame) t) ;;; to be redefined by objects if they have a specific miniview (defmethod draw-mini-view ((object t) (box OMBox) x y w h &optional time) nil) ;; the bold text that is written on the object box (defmethod object-box-label ((object t)) (string-upcase (type-of object))) (defmethod object-box-label ((object null)) "NIL") (defmethod draw-label ((box OMBox) object &key color) (let ((frame (frame box)) (str (if (eval-flag box) ".oO__.." (object-box-label object)))) (multiple-value-bind (sw sh) (om-string-size str *box-label-font*) (declare (ignore sw)) (let* ((lines (om-string-wrap str (- (w frame) 18) *box-label-font*)) (y0 (max 24 (- (+ 6 (/ (h frame) 2)) (round (* (1- (length lines)) sh) 2))))) (om-with-font *box-label-font* (om-with-fg-color (or color (om-make-color 0.6 0.6 0.6 0.5)) (loop for line in lines for y = y0 then (+ y sh) do (om-draw-string 10 y line) ))) )))) (defmethod draw-mini-text ((object t) (box OMBox) x y w h &optional time) (let ((type-str (string-upcase (type-of object))) (type-font (om-def-font :small-b))) (om-draw-string (+ x (- w (om-string-size type-str type-font) 12)) (+ y 18) type-str :font type-font :color (om-def-color :gray))) (om-with-font (om-def-font :small) (loop for i = (+ y 30) then (+ i 10) for sl in (ensure-cache-display-text box object) while (< i (- h 6)) do (om-draw-string (+ x 4) i (format nil "~A: ~A" (car sl) (cadr sl)))) )) (defmethod draw-type-of-object ((object t)) (string-upcase (type-of object))) (defparameter *miniview-x-margin* 4) (defparameter *miniview-y-margin* 4) (defmethod draw-value-in-frame ((object t) (frame OMObjectBoxFrame)) (let ((box (object frame))) (case (display box) (:text (draw-label box object :color (om-make-color 0.6 0.6 0.6 0.2)) (draw-mini-text object box 0 0 (w frame) (h frame) (box-play-time frame))) (:mini-view (om-with-clip-rect frame *miniview-x-margin* *miniview-y-margin* (- (w frame) (* 2 *miniview-x-margin*)) (- (h frame) (* 2 *miniview-y-margin*)) (when (> (w frame) 30) (draw-label box object :color (om-make-color 0.6 0.6 0.6 0.2))) (ensure-cache-display-draw box object) (draw-mini-view object box *miniview-x-margin* *miniview-y-margin* (- (w frame) (* 2 *miniview-x-margin*)) (- (h frame) (* 2 *miniview-y-margin*)) (box-play-time frame)) )) (:hidden (om-with-clip-rect frame 0 *miniview-y-margin* (w frame) (- (h frame) (* 2 *miniview-y-margin*)) (draw-label box object))) (otherwise nil) ) (when (play-state box) (draw-cursor-on-box (get-obj-to-play box) frame (box-play-time frame))) )) (defmethod time-to-pixel ((self omobjectboxframe) x) (miniview-time-to-pixel (get-box-value (object self)) (object self) self x)) (defmethod miniview-time-to-pixel (object box view time) (* (w view) (/ time (if (plusp (get-obj-dur object)) (get-obj-dur object) 1000)))) (defmethod draw-cursor-on-box (object frame time) (when time (om-with-fg-color (om-make-color 0.73 0.37 0.42) (let ((x (miniview-time-to-pixel object (object frame) frame time))) ; (print (list "cursor" time x)) (om-draw-polygon (list (- x 5) 4 x 9 (+ x 5) 4) :fill t) (om-with-line '(2 2) (om-draw-line x 4 x (- (h frame) 6)) ))) t)) ;;; specific update depending on context (defmethod contextual-update ((self OMBox) (container t)) nil) (defmethod update-after-eval ((self OMBoxEditCall)) (when (frame self) (reset-cache-display self) (let ((val (car (value self)))) ;;; if the object has a name, the box takes the object name ;;; if not, the object takes the box name... (if (get-name val) (setf (name self) (get-name val)) (set-name val (name self)))) (om-invalidate-view (frame self))) (contextual-update self (container self)) (when (editor self) (update-to-editor (editor self) self))) (defmethod update-from-editor ((self OMBoxEditCall) &key (value-changed t) (reactive t)) (declare (ignore reactive)) ;;; reactive is handled in a :around method (when value-changed (setf (lock-state self) :locked) (contextual-update self (container self)) (when (frame self) ;(update-inspector-for-object self) ;; ? sure about this ? ; => removed: caused problems with BPF editor draw when inspector is open :( (reset-cache-display self) (om-invalidate-view (frame self))) ) (report-modifications (editor (container self)))) ;;=========================================== ;; THE SLOTS BOX ;;=========================================== (defclass OMSlotsBox (OMBoxRelatedWClass) () (:metaclass omstandardclass) (:default-initargs :border nil)) (defmethod default-size ((self OMSlotsBox)) (minimum-size self)) (defmethod v-resizable ((self OMSlotsBox)) nil) (defmethod get-box-help ((self OMSlotsBox)) (format nil "Get/set values for the slots of a ~A" (string-upcase (reference self)))) ;;; init-args MUST be a class (defmethod omNG-make-new-boxcall ((reference (eql 'slots)) pos &optional init-args) (make-slots-boxcall init-args pos)) (defmethod make-slots-boxcall ((reference standard-class) pos) (let* ((box (make-instance 'OMSlotsBox :name (string+ (string-upcase (class-name reference)) " SLOTS") :reference (class-name reference) :icon-pos :left :color (om-make-color 0.9 0.88 0.81) :text-align :left)) (size (default-size box))) (setf (box-x box) (om-point-x pos) (box-y box) (om-point-y pos) (box-w box) (om-point-x size) (box-h box) (om-point-y size)) box)) (defmethod make-slots-boxcall ((reference OMClass) pos) (let ((box (call-next-method))) (retain-reference reference box) box)) (defmethod make-slots-boxcall ((reference t) pos) (om-beep-msg "Error: can not create a SLOTS box from ~A" reference)) ;;=========================================== ;; 'INSTANCE' BOX ;;=========================================== (defmethod make-new-box-with-instance ((instance standard-object) pos &optional connect-to) (let ((box (omng-make-new-boxcall (class-of instance) pos instance))) (when box (setf (display box) :mini-view)) (values box (when connect-to (omng-make-new-connection connect-to (car (inputs box))))) )) (defmethod make-new-box-with-instance ((instance cons) pos &optional connect-to) (if (and (list-subtypep instance 'standard-object) (list-typep instance (type-of (car instance)))) (let ((box (omng-make-new-boxcall (find-class 'collection) pos))) (when box (setf (obj-list (get-box-value box)) instance) (om-init-instance (get-box-value box)) (setf (display box) :text)) (values box (when connect-to (omng-make-new-connection connect-to (second (inputs box)))) )) (call-next-method))) (defmethod make-new-box-with-instance ((instance t) pos &optional connect-to) (let ((box (omng-make-new-boxcall 'value pos instance))) (values box (when connect-to (optional-input++ box) (omng-make-new-connection connect-to (car (inputs box))))) ))

Common Lisp

.lisp

cac-t-u-s/om-sharp

GPL-3.0

9/19/2024, 11:25:22 AM (Europe/Amsterdam)

a3988bbcb273b3f10d985759970c35b8c5aaf0fba7d70d00330f2ef61d6b6926

encapsulation.lisp

cac-t-u-s_om-sharp/src/visual-language/patch/encapsulation.lisp

;============================================================================ ; om#: visual programming language for computer-assisted music composition ;============================================================================ ; ; This program is free software. For information on usage ; and redistribution, see the "LICENSE" file in this distribution. ; ; This program 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. ; ;============================================================================ ; File authors: J. Bresson, G. Holbrook ;============================================================================ ;================================================================= ; ENCAPSULATION ; Patch encapsulation / de-encapsulation by Geof Holbrook in OM 6 ; Adaptation J. Bresson - 2016 ;================================================================= (in-package :om) (defmethod normalize-positions ((self ompatch)) (let ((minx (apply 'min (mapcar 'box-x (boxes self)))) (miny (apply 'min (mapcar 'box-y (boxes self))))) (loop for box in (boxes self) do (move-box box (- 50 minx) (- 50 miny))))) (defmethod shrink-patch-window-size ((self ompatch)) (let ((maxx (apply 'max (mapcar #'(lambda (b) (+ (box-x b) (box-w b))) (boxes self)))) (maxy (apply 'max (mapcar #'(lambda (b) (+ (box-y b) (box-h b))) (boxes self))))) (setf (window-size self) (om-make-point (+ maxx 100) (+ maxy 100))))) ;;; a slightly modified version of 'save-connections-from-boxes' ;;; where source boxes and dest boxes are two different sets (defmethod save-connections-from-boxes-2 (source-boxes dest-boxes) (loop for box in source-boxes for b = 0 then (+ b 1) append (loop for out-c in (get-out-connections box) for c = 0 then (+ c 1) when (find (box (to out-c)) dest-boxes) collect (list :connection (list :from (list :box b :out (position (from out-c) (outputs box)))) ;; (box out) (list :to (list :box (position (box (to out-c)) dest-boxes) :in (position (to out-c) (inputs (box (to out-c)))))) ;;; (box in) (list :attributes (list :color (omng-save (color out-c)) :style (style out-c) :modif (modif out-c))) )))) (defmethod make-incoming-connections ((patch ompatch) bridges outside-boxes inside-boxes) (loop for connection in bridges for origin = (find-value-in-kv-list (cdr connection) :from) for destination = (find-value-in-kv-list (cdr connection) :to) for index = 0 then (+ index 1) collect ;with entries ;; keep track of new input boxes, with entries of the form (input-obj inactives-ordinal output-ordinal input-ordinal) ;with input-ord (let ((dest-box (nth (getf destination :box) inside-boxes)) (dest-in (getf destination :in)) (origin-box (nth (getf origin :box) outside-boxes)) (origin-out (getf origin :out))) (let ((new-in (omng-make-new-boxcall (make-instance 'OMIn :name (string+ "input " (prin1-to-string (1+ index)))) (om-make-point (+ (box-x dest-box) (* dest-in (round (box-w dest-box) (length (inputs dest-box))))) (- (box-y dest-box) 50)) nil))) (omng-add-element patch new-in) ;; connection inside the patch (omng-add-element patch (omng-make-new-connection (car (outputs new-in)) (nth dest-in (inputs dest-box)) `(:style :curved :color ,(om-def-color :dark-blue)) )) ;; collect the outputs from outside (nth origin-out (outputs origin-box)) )))) (defmethod make-outgoing-connections ((patch ompatch) bridges outside-boxes inside-boxes) (let ((grouped-bridges nil)) ;; pre-process to group the outputs when possible (loop for connection in bridges do (let ((existpos (position (find-value-in-kv-list (cdr connection) :from) grouped-bridges :key 'cadar :test 'equal))) (if existpos (setf (nth existpos grouped-bridges) (append (nth existpos grouped-bridges) `((:to ,(find-value-in-kv-list (cdr connection) :to))))) (push `((:from ,(find-value-in-kv-list (cdr connection) :from)) (:to ,(find-value-in-kv-list (cdr connection) :to))) grouped-bridges)))) (loop for connection in (reverse grouped-bridges) for index = 0 then (+ index 1) collect (let ((origin-box (nth (getf (cadr (car connection)) :box) inside-boxes)) (origin-out (getf (cadr (car connection)) :out))) (let ((new-out (omng-make-new-boxcall (make-instance 'OMOut :name (string+ "output " (prin1-to-string (1+ index)))) (om-make-point (+ (box-x origin-box) (* origin-out 35)) (+ (box-y origin-box) (box-h origin-box) 25)) nil))) (omng-add-element patch new-out) ;; connection inside the patch (omng-add-element patch (omng-make-new-connection (nth origin-out (outputs origin-box)) (car (inputs new-out)) `(:style :curved :color ,(om-def-color :dark-blue)))) ;; collect the destination input(s) (loop for destination in (cdr connection) collect (let ((dest-box (nth (getf (cadr destination) :box) outside-boxes)) (dest-in (getf (cadr destination) :in))) (nth dest-in (inputs dest-box)))) ))) )) (defun can-encapsulate (boxes) ;;; forbidden case: boxes are linked together but not all of the path is included (let ((guard nil)) (loop for box in boxes while (not guard) do (loop for other-box in (remove box boxes) while (not guard) when (is-connected-up-to box other-box) do (loop for branch in (print (get-all-branches box other-box)) while (not guard) do (when (find-if #'(lambda (box) (not (find box boxes))) branch) (setf guard t))))) (not guard) )) (defmethod encapsulate-patchboxes ((editor patch-editor) (view patch-editor-view) boxes) (let ((active-boxes (remove-if #'(lambda (box) (typep box 'OMInOutBox)) boxes))) (if (can-encapsulate active-boxes) (let* ((thispatch (object editor)) (inactive-boxes (remove-if #'(lambda (box) (find box active-boxes)) (boxes thispatch))) (newpatch (make-instance 'OMPatchInternal :name "my-patch")) (patchbox (omng-make-new-boxcall newpatch (om-make-point (round (average (mapcar 'box-x active-boxes) nil)) (round (average (mapcar 'box-y active-boxes) nil))) nil))) (store-current-state-for-undo editor) ;insert new patch in current window (add-box-in-patch-editor patchbox view) (let ((copies (mapcar 'om-copy active-boxes)) (connections (save-connections-from-boxes active-boxes)) (coming-in (sort (save-connections-from-boxes-2 inactive-boxes active-boxes) #'(lambda (b1 b2) (if (= (getf b1 :box) (getf b2 :box)) (< (getf b1 :out) (getf b2 :out)) (< (box-x (nth (getf b1 :box) inactive-boxes)) (box-x (nth (getf b2 :box) inactive-boxes))))) :key #'(lambda (bridge) (find-value-in-kv-list (cdr bridge) :from)))) (going-out (sort (save-connections-from-boxes-2 active-boxes inactive-boxes) #'(lambda (b1 b2) (if (= (getf b1 :box) (getf b2 :box)) (< (getf b1 :in) (getf b2 :in)) (< (box-x (nth (getf b1 :box) inactive-boxes)) (box-x (nth (getf b2 :box) inactive-boxes))))) :key #'(lambda (bridge) (find-value-in-kv-list (cdr bridge) :to))))) ;add the copies to the new patch (loop for copy in copies do (omng-add-element newpatch copy)) (loop for c in (restore-connections-to-boxes connections copies) do (omng-add-element newpatch c)) ;MAKE THRESHOLD CONNECTIONS IN (let ((dest-outs (make-incoming-connections newpatch coming-in inactive-boxes copies))) (loop for dest-output in dest-outs for i = 0 then (+ i 1) do (let ((connection (omng-make-new-connection dest-output (nth i (inputs patchbox)) `(:color ,(om-def-color :dark-blue)) ))) (omng-add-element thispatch connection) (add-connection-in-view view connection)))) ;MAKE THRESHOLD CONNECTIONS OUT (let ((dest-ins (make-outgoing-connections newpatch going-out inactive-boxes copies))) (loop for dest-input-set in dest-ins for i = 0 then (+ i 1) do (loop for dest-input in dest-input-set do (let ((connection (omng-make-new-connection (nth i (outputs patchbox)) dest-input `(:color ,(om-def-color :dark-blue))))) ;;; remove previous connection (loop for c in (connections dest-input) do (omng-remove-element thispatch c)) (omng-add-element thispatch connection) (add-connection-in-view view connection))))) (normalize-positions newpatch) (shrink-patch-window-size newpatch) ;remove the original boxes (remove-boxes editor active-boxes) (select-box patchbox t) (om-invalidate-view view) (report-modifications editor) )) ;;; else (can-encapsulate): (om-beep-msg "Selected boxes can not be encapsulated!") ))) ;=============================== ; UN-ENCAPSULATE ;=============================== (defmethod unencapsulate-patchboxes ((editor patch-editor) view boxes) (store-current-state-for-undo editor) (mapc #'(lambda (b) (unencapsulate-box b editor view)) boxes)) (defmethod unencapsulate-box ((box t) (editor patch-editor) view) (om-beep-msg "Selected box: ~S can not be un-encapsulated" (name box))) (defmethod center-positions-around (boxes position) (when boxes (let ((move-x (- (om-point-x position) (average (mapcar 'box-x boxes) nil))) (move-y (- (om-point-y position) (average (mapcar 'box-y boxes) nil)))) (loop for box in boxes do (move-box box move-x move-y))))) (defmethod decapsulable ((self OMPatch)) t) (defmethod unencapsulate-box ((box omboxpatch) (editor patch-editor) view) (when (decapsulable (object editor)) (let* ((patch (object editor)) (sub-patch (reference box)) (all-boxes (boxes sub-patch)) (all-connections (save-connections-from-boxes all-boxes)) (internal-boxes (remove-if #'(lambda (box) (subtypep (type-of box) 'OMInOutBox)) all-boxes)) (internal-connections (save-connections-from-boxes internal-boxes)) (copies (mapcar 'om-copy all-boxes)) (internal-copies (remove-if #'(lambda (box) (subtypep (type-of box) 'OMInOutBox)) copies))) ; reposition the new boxes (center-positions-around internal-copies (omp (box-x box) (box-y box))) ; add boxes in the main patch (except the io boxes) (loop for box in internal-copies do (add-box-in-patch-editor box view)) ; restore to in/out connections (loop for ext-c in all-connections do (let* ((from (find-value-in-kv-list (cdr ext-c) :from)) (from-box (nth (getf from :box) copies)) (from-out (nth (getf from :out) (outputs from-box))) (to (find-value-in-kv-list (cdr ext-c) :to)) (to-box (nth (getf to :box) copies)) (to-in (nth (getf to :in) (inputs to-box)))) (cond ((and (typep from-box 'ominbox) (typep to-box 'omoutbox)) (let* ((index-i (index (reference (nth (getf from :box) all-boxes)))) (index-o (index (reference (nth (getf to :box) all-boxes)))) (connections-i (connections (nth (1- index-i) (inputs box)))) ;; in principle there can be no more than one (connections-o (connections (nth (1- index-o) (outputs box))))) (when connections-i (loop for c in connections-o do (let ((new-connection (omng-make-new-connection (from (car connections-i)) (to c) `(:color ,(om-def-color :dark-blue))))) (omng-add-element patch new-connection) (add-connection-in-view view new-connection))) ))) ((typep from-box 'ominbox) (let* ((index (index (reference (nth (getf from :box) all-boxes)))) ;; the original one (copies don't keep the id) (connections (connections (nth (1- index) (inputs box))))) ;; in principle there can be no more than one (loop for c in connections do (let ((new-connection (omng-make-new-connection (from c) ; who is connected to the index-th inlet of the box patch to-in `(:color ,(om-def-color :dark-blue))))) (omng-add-element patch new-connection) (add-connection-in-view view new-connection))) )) ((typep to-box 'omoutbox) (let* ((index (index (reference (nth (getf to :box) all-boxes)))) ;; the original one (copies don't keep the id) (connections (connections (nth (1- index) (outputs box))))) (loop for c in connections do (let ((new-connection (omng-make-new-connection from-out (to c) ; who is connected to the index-th inlet of the box patch `(:color ,(om-def-color :dark-blue))))) (loop for old-connection in (connections (to c)) ;; in principle there can only be one do (omng-remove-element patch old-connection)) (omng-add-element patch new-connection) (add-connection-in-view view new-connection)) ))) ))) ; restore the rest of internal connections (loop for c in (restore-connections-to-boxes internal-connections internal-copies) do (omng-add-element patch c) do (add-connection-in-view view c)) ; remove the original patch box (remove-boxes editor (list box)) ; set the new boxes selected (loop for b in copies do (select-box b t)) (om-invalidate-view view) (report-modifications editor) )))

Common Lisp

.lisp

cac-t-u-s/om-sharp

GPL-3.0

9/19/2024, 11:25:22 AM (Europe/Amsterdam)

52f467a43ac1266477e5bb8904ea9414115486dfe8a0d4a0410598a8da0e9266

boxcall.lisp

cac-t-u-s_om-sharp/src/visual-language/patch/boxcall.lisp

;============================================================================ ; om#: visual programming language for computer-assisted music composition ;============================================================================ ; ; This program is free software. For information on usage ; and redistribution, see the "LICENSE" file in this distribution. ; ; This program 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. ; ;============================================================================ ; File author: J. Bresson ;============================================================================ (in-package :om) ;--------------------------------------- ;Boxes in a Patch ;--------------------------------------- (defclass OMBoxCall (OMBox) ((lock-state :initform nil :accessor lock-state :initarg :lock-state) ;;; can be (nil :locked :eval-once) (lambda-state :initform nil :accessor lambda-state :initarg :lambda-state) ;;; can be (nil :lambda :reference :box) (ev-once-flag :accessor ev-once-flag :initform nil) (eval-flag :accessor eval-flag :initform nil)) (:documentation "This is the class for boxes which can be evaluated.") (:metaclass omstandardclass)) (defmethod omNG-make-new-boxcall ((reference t) pos &optional init-args) nil) (defmethod add-keyword-input ((self t) &key key (value nil val-supplied-p) doc reactive) (declare (ignore key value val-supplied-p doc reactive)) nil) (defmethod add-optional-input ((self t) &key name (value nil val-supplied-p) doc reactive) (declare (ignore name value val-supplied-p doc reactive)) nil) (defmethod allow-rename ((self OMBoxcall)) nil) ;------------------------------------------- ; PROPERTIES ;------------------------------------------- (defmethod lock-modes-for-box ((self OMBoxCall)) (append '(nil :locked) (if (get-pref-value :general :auto-ev-once-mode) nil '(:eval-once)))) (defmethod eval-modes-for-box ((self OMBoxCall)) '(nil :lambda :reference :box)) (defmethod get-properties-list ((self OMBoxCall)) (append (call-next-method) `(("Execution" ;;; category (:lock "Lock state (b/1)" ,(lock-modes-for-box self) lock-state) ;;; id text type slot (:lambda "Eval mode" ,(eval-modes-for-box self) lambda-state) ;;; ex. :bool (:reactive "Reactive (r)" :bool reactive))))) (defmethod set-property ((object OMBoxCall) (prop-id (eql :lambda)) val) (set-lambda object val)) (defmethod set-lambda ((self OMBoxCall) value) ;;; reinit value only if switch from lambda to normal (when (or (and (equal (lambda-state self) :lambda) (equal value nil)) (and (equal (lambda-state self) nil) (equal value :lambda))) (setf (value self) nil)) (setf (lambda-state self) value)) (defmethod update-after-change-mode ((box OMBox)) (let ((ed (and (container box) (editor (container box))))) (if ed (update-inspector-for-editor ed nil t) ;;; will take into account possible multiple selection etc. (update-inspector-for-object box)) ;;; does this (no editor) really happens ? (om-invalidate-view (frame box)) (when ed (report-modifications ed)))) (defmethod set-lock-state ((box OMBoxCall) mode) (setf (lock-state box) mode) (update-after-change-mode box)) (defmethod switch-lock-mode ((self t)) nil) (defmethod switch-lambda-mode ((self t)) nil) (defmethod switch-evonce-mode ((self t)) nil) (defmethod switch-lock-mode ((box OMBoxCall)) (when (valid-property-p box :lock) (set-lock-state box (if (lock-state box) nil :locked)))) (defmethod switch-evonce-mode ((box OMBoxCall)) (when (valid-property-p box :lock) (set-lock-state box (if (equal (lock-state box) :eval-once) nil :eval-once)) )) (defmethod switch-lambda-mode ((box OMBoxCall)) (when (and (valid-property-p box :lambda) (member :lambda (eval-modes-for-box box))) (set-lambda box (if (lambda-state box) nil :lambda)) (update-after-change-mode box) )) (defmethod set-property ((object OMBox) (prop-id (eql :reactive)) val) (set-reactive object val)) (defmethod all-reactive-p ((self OMBox)) (and (or (inputs self) (outputs self)) (not (find-if-not 'reactive (append (inputs self) (outputs self)))))) (defmethod set-reactive ((self OMBox) val) (setf (reactive self) val) (mapc #'(lambda (io) (setf (reactive io) val)) (append (inputs self) (outputs self)))) (defmethod set-reactive-mode ((box OMBox)) (set-reactive box (not (reactive box))) (update-after-change-mode box) (update-frame-connections-display (frame box))) (defmethod update-reactive-state ((box OMBox)) (setf (reactive box) (all-reactive-p box)) (update-after-change-mode box)) ;-------------------------------------- ; DEFAULT OUTPUTS ;------------------------------------------- (defmethod inputs-visible ((self OMBoxCall)) (equal :reference (lambda-state self))) ;;; VERIFY/DECIDE IF THE INPUTS/OUTPUTS NAMES ARE SYMBOLS OR STRINGS !! (defmethod create-box-outputs ((self OMBoxCall)) (loop for i from 0 to (1- (box-n-outs self)) collect (make-instance 'box-output :box self :name (if (= 1 (box-n-outs self)) "out" (format nil "out~D" i)) :reference i :doc-string (get-output-doc self i)))) ;------------------------------------------- ; EDITOR ;------------------------------------------- (defmethod open-editor ((self OMBoxCall)) (when (object-has-editor (reference self)) (open-editor (reference self)))) ;;; for temporary in/outputs, the reference is sometimes just a number (defmethod copy-if-exists ((io OMBoxIO) n iolist) (let ((exists (find-if #'(lambda (old-io) (or (and (numberp (reference old-io)) (= (reference old-io) n)) (equal (reference io) (reference old-io)))) iolist))) (if exists (copy-io exists) io) )) (defmethod update-from-reference ((self OMBoxCall)) (let ((new-inputs (append (loop for i in (create-box-inputs self) for n from 0 collect (copy-if-exists i n (inputs self))) (get-optional-inputs self) (get-keyword-inputs self))) (new-outputs (append (loop for o in (create-box-outputs self) for n from 0 collect (copy-if-exists o n (outputs self))) (get-keyword-outputs self)))) ;;; remove former i-o connections (let ((patch (container self))) (when patch (loop for io in (append (get-standard-inputs self) (get-standard-outputs self)) do (loop for c in (connections io) do (omng-remove-element patch c))))) (set-box-inputs self new-inputs) (set-box-outputs self new-outputs) (set-frame-areas (frame self)) (om-invalidate-view (frame self)) t)) ;------------------------------------------- ; BOX FOR FUNCTIONS ;------------------------------------------- (defclass OMFunBoxcall (OMBoxcall) () (:metaclass omstandardclass)) (defmethod omNG-make-new-funboxcall ((reference symbol) pos &optional (init-args nil args-supplied-p)) (let* ((box (make-instance (or (get-box-class reference) ;; symbol name takes precedence (get-box-class (fdefinition reference))) :name (string-downcase reference) :reference reference)) (size (minimum-size box))) (setf (box-x box) (om-point-x pos) (box-y box) (om-point-y pos) (box-w box) (om-point-x size) (box-h box) (om-point-y size)) (when args-supplied-p (add-args-to-box box init-args)) box)) (defmethod omNG-make-new-boxcall ((reference symbol) pos &optional (init-args nil args-supplied-p)) (if (fboundp reference) (if args-supplied-p (omNG-make-new-funboxcall reference pos init-args) (omNG-make-new-funboxcall reference pos)) (call-next-method))) (defmethod omNG-make-new-boxcall ((reference function) pos &optional (init-args nil args-supplied-p)) (let* ((symbol (function-name reference))) (if args-supplied-p (omNG-make-new-funboxcall symbol pos init-args) (omNG-make-new-funboxcall symbol pos)))) (defmethod box-n-outs ((self OMFunBoxcall)) 1) (defmethod h-resizable ((self OMFunBoxCall)) t) (defmethod v-resizable ((self OMFunBoxCall)) nil) (defmethod create-box-inputs ((self OMFunBoxcall)) (mapcar #'(lambda (arg) (make-instance 'box-input :name (string arg) :reference arg :box self :value (get-input-def-value self arg) :doc-string (get-input-doc self arg))) (subseq (function-arglist (reference self)) 0 (function-n-args (reference self))))) (defmethod add-args-to-box (box args) (let ((main-args (firstn args (length (inputs box)))) (other-args (nthcdr (length (inputs box)) args))) (mapcar #'(lambda (input val) (setf (value input) val)) (inputs box) main-args) (loop while other-args do (let ((arg (pop other-args))) (or (more-optional-input box :value arg) (and (symbolp arg) (string-equal "KEYWORD" (package-name (symbol-package arg))) (more-keyword-input box :key arg :value (pop other-args))) (om-beep))) ))) (defmethod next-optional-input ((self OMFunBoxcall)) (let ((current-inp (length (inputs self))) (lambda-lis (function-arglist (reference self)))) (cond ((< current-inp (+ (function-n-args (reference self)) (length (function-optional-args (reference self))))) (nth current-inp (function-arg-list (reference self)))) ((find '&rest lambda-lis) (nth (1+ (position '&rest lambda-lis)) lambda-lis)) (t nil)))) (defmethod more-optional-input ((self OMFunBoxcall) &key name (value nil val-supplied-p) doc reactive) (declare (ignore doc)) (let ((new-in (next-optional-input self))) (when (and name (not (string-equal name (string new-in)))) (om-print-dbg "Trying to set optional input with name: ~A -- The next in the list is now: ~A" (list name new-in) "Warning")) (when new-in (add-optional-input self :name new-in :value (if val-supplied-p value (get-input-def-value self new-in)) :doc (get-input-doc self new-in) :reactive reactive) t) )) (defmethod get-all-keywords ((self OMFunBoxcall)) (list (function-keyword-args (reference self)))) ;; is this class useful ? (defclass OMFunBoxFrame (OMBoxFrame) ()) (defmethod get-box-frame-class ((self OMFunBoxcall)) 'OMFunBoxFrame) (defmethod resize-areas ((self OMFunBoxFrame)) (list (make-instance 'h-resize-area :object self :frame self :pos #'(lambda (f) (om-make-point (- (w f) 8) 16)) :pick #'(lambda (f) (list 0 0 12 (- (h f) 16)))) )) ;;; Does the box scale if placed in a timed view (e.g. a sequencer track) (defmethod scale-in-x-? ((self OMFunBoxCall)) nil) (defmethod scale-in-y-? ((self OMFunBoxCall)) nil) (defmethod get-properties-list ((self OMFunBoxCall)) (add-properties (hide-properties (call-next-method) '(:group-id)) "Appearance" '((:icon "Icon position" (:left :top :noicon :default) icon-pos (:appearance :box-icon))) )) (defmethod draw-name-as-icon ((box OMFunBoxCall) frame) (let* ((pack (symbol-package (reference box))) (pname (or (car (package-nicknames pack)) (package-name pack))) (font (om-make-font "Verdana" 7 :style '(:bold)))) (om-draw-rounded-rect 2 6 20 (- (h frame) 12) :color (om-def-color :gray) :fill t :round 5) (om-draw-string (- 8 (* (length pname) 1.2)) 17 pname :font font :color (om-def-color :light-gray)) t)) ;------------------------------------------- ; BOX FOR STANDARD LISP FUNCTIONS ;------------------------------------------- (defclass OMLispFBoxcall (OMFunBoxcall) () (:metaclass omstandardclass)) (defmethod get-box-class ((self t)) nil) (defmethod get-box-class ((self function)) (or (get-box-class (function-name self)) 'OMLispFBoxcall)) (defmethod get-object-type-name ((self OMLispFBoxcall)) "Standard Lisp Function") (defmethod get-icon-id ((self OMLispFBoxcall)) nil) ;; lisp ;; (defmethod box-draw ((self OMLispFBoxcall) (frame OMBoxFrame)) (call-next-method)) ;------------------------------------------- ; BOX FOR OMGENERICFUNCTION ;------------------------------------------- ;;; TODO: MAINTAIN A REFERENCES-TO LIST IN REFERENCE GENFUN (defclass OMGFBoxcall (OMFunBoxcall) () (:metaclass omstandardclass)) (defmethod boxclass-from-function-name ((self t)) 'OMGFBoxCall) (defmethod get-box-class ((self OMGenericFunction)) (boxclass-from-function-name (function-name self))) (defmethod get-object-type-name ((self OMGFBoxcall)) "Generic Function") (defmethod get-icon-id ((self OMGFBoxcall)) (let ((ic (icon (fdefinition (reference self))))) (and ic (if (numberp ic) ic (intern-k (format nil "~A" ic))) ))) (defmethod box-n-outs ((self OMGFBoxcall)) (numouts (fdefinition (reference self)))) (defmethod get-output-doc ((self OMGFBoxCall) i) (let ((txt (nth i (outputs-doc (fdefinition (reference self)))))) (if txt (format nil "out~D: ~A" i txt) (call-next-method)))) (defmethod get-input-doc ((self OMGFBoxCall) name) (let* ((fun (fdefinition (reference self))) (pos (position name (function-arg-list fun) :key 'string :test 'string-equal))) (when pos (nth pos (inputs-doc fun))))) (defmethod get-input-def-value ((self OMGFBoxCall) name) (let* ((fun (fdefinition (reference self))) (pos (position name (function-arg-list fun) :key 'string :test 'string-equal))) (when pos (nth pos (inputs-default fun))))) (defmethod get-input-menu ((self OMGFBoxCall) name) (let* ((fun (fdefinition (reference self))) (pos (position name (function-arg-list fun) :key 'string :test 'string-equal))) (when pos (nth pos (inputs-menus fun))))) ;(inputs-menus (fdefinition 'sort-list))

Common Lisp

.lisp

cac-t-u-s/om-sharp

GPL-3.0

9/19/2024, 11:25:22 AM (Europe/Amsterdam)

82273d9b3dc496617782c6d2e390c308ab4a1ebaeaf4e4db642bb9d446451365

boxframe.lisp

cac-t-u-s_om-sharp/src/visual-language/patch/boxframe.lisp

;============================================================================ ; om#: visual programming language for computer-assisted music composition ;============================================================================ ; ; This program is free software. For information on usage ; and redistribution, see the "LICENSE" file in this distribution. ; ; This program 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. ; ;============================================================================ ; File author: J. Bresson ;============================================================================ ;========================================================================= ;;;================================ ;;; Basic frames for boxes ;;;================================ (in-package :om) ;;; A Frame whose object is an OMBox (defclass OMBoxFrame (OMSimpleFrame) ((icon-id :accessor icon-id :initform nil :initarg :icon-id) (icon :accessor icon :initform nil) (icon-size :accessor icon-size :initform nil))) (defmethod get-help ((self OMBoxFrame)) (get-box-help (object self))) (defmethod get-box-help ((self OMBox)) nil) ;;; calculates "non graphic" coordinates in view from pixel pos (defmethod omng-x ((container t) pix-x) pix-x) (defmethod omng-y ((container t) pix-y) pix-y) (defmethod omng-w ((container t) pix-w) pix-w) (defmethod omng-h ((container t) pix-h) pix-h) (defmethod omng-position ((container t) pix-position) (omp (omng-x container (om-point-x pix-position)) (omng-y container (om-point-y pix-position)))) (defmethod omng-size ((container t) pix-size) (omp (omng-w container (om-point-x pix-size)) (omng-h container (om-point-y pix-size)))) ;;; calculates "graphic" coordinates in view from symbolic values (defmethod omg-x ((container t) s-x) s-x) (defmethod omg-y ((container t) s-y) s-y) (defmethod omg-w ((container t) s-w) s-w) (defmethod omg-h ((container t) s-h) s-h) (defmethod omg-position ((container t) s-position) (omp (omg-x container (om-point-x s-position)) (omg-y container (om-point-y s-position)))) (defmethod omg-size ((container t) s-size) (omp (omg-w container (om-point-x s-size)) (omg-h container (om-point-y s-size)))) (defmethod omg-add-element ((container t) (frame OMFrame)) (let ((scaledsize (omg-size container (omp (box-w (object frame)) (box-h (object frame))))) (scaledpos (omg-position container (omp (box-x (object frame)) (box-y (object frame)))))) (om-set-view-position frame scaledpos) (om-set-view-size frame (omp (if (scale-in-x-? (object frame)) (om-point-x scaledsize) (box-w (object frame))) (if (scale-in-y-? (object frame)) (om-point-y scaledsize) (box-h (object frame))))) (om-add-subviews container frame))) (defmethod delete-box-frame ((frame t)) nil) (defmethod delete-box-frame ((frame OMBoxFrame)) ;;; here we are lucky that om-view-container is NIL in a sequencer-track-view ;;; but this is dangerous and should be specialized in some way (when (om-view-container frame) (om-remove-subviews (om-view-container frame) frame)) ;;; tell the box that it has no more frame! (setf (frame (object frame)) nil) t) ;;;================================ ;;; I/O areas ;;;================================ (defclass io-area (frame-area) ((temp-locked :initform nil :accessor temp-locked))) (defmethod io-position-in-patch ((self io-area)) (om-add-points (om-view-position (frame self)) (get-position self))) (defclass input-area (io-area) ()) (defclass output-area (io-area) ()) (defmethod io-color ((self OMBoxIO)) (om-def-color :dark-gray)) (defmethod io-color ((self box-optional-input)) (om-def-color :gray)) (defmethod io-color ((self box-keyword-input)) (om-make-color 0.2 0.4 0.5)) (defmethod io-color ((self box-keyword-output)) (om-make-color 0.2 0.4 0.5)) (defmethod area-tt-text ((self input-area)) (remove nil (list (string+ (format nil "~A~A" (io-prefix (object self)) (or (name (object self)) "")) (if (connections (object self)) "" (format nil " [~s]" (value (object self))))) (get-input-doc-string (object self)) ))) (defmethod area-tt-text ((self output-area)) (if (doc-string (object self)) (list (name (object self)) (doc-string (object self))) (name (object self)))) (defmethod area-tt-pos ((self output-area)) (om-add-points (call-next-method) (om-make-point 30 30))) (defmethod om-enter-area ((area io-area)) (unless (temp-locked area) (call-next-method))) (defparameter +active-r+ 5) (defparameter +inactive-r+ 2.5) (defmethod om-draw-area ((area io-area)) (let ((p (get-position area)) (r (if (and (active area) (not (edit-lock (editor (om-view-container (frame area)))))) +active-r+ +inactive-r+))) (when (reactive (object area)) (om-draw-circle (om-point-x p) (om-point-y p) (1+ r) :fill t :color (om-def-color :dark-red))) (om-draw-circle (om-point-x p) (om-point-y p) r :fill t :color (io-color (object area))) )) (defmethod inputs-visible ((self OMBox)) t) (defmethod om-draw-area ((area input-area)) (call-next-method) (when (inputs-visible (object (frame area))) (let ((p (get-position area))) (om-draw-circle (om-point-x p) (om-point-y p) +inactive-r+ :fill t :color (om-def-color :light-gray)) ))) ;;;============================= ;;; BOX I/O EDITS ;;;============================= (defclass input-edit-area (frame-area) ()) (defclass ++input-area (input-edit-area) ()) (defclass --input-area (input-edit-area) ()) (defmethod disabled-area ((area input-edit-area)) (container-frames-locked (om-view-container (frame area)))) (defmethod area-tt-text ((self ++input-area)) "add optional/keyword input") (defmethod area-tt-text ((self --input-area)) "remove optional/keyword input") (defmethod allow-remove-inputs ((self OMBox)) (or (get-optional-inputs self) (get-keyword-inputs self))) (defmethod allow-add-inputs ((self OMBox)) (or (next-optional-input self) (next-keyword-input self))) (defmethod input-edit-areas ((self OMBoxFrame)) (let ((S 5) (allow-add (allow-add-inputs (object self))) (allow-remove (allow-remove-inputs (object self)))) (remove nil (list (when (allow-add-inputs (object self)) (make-instance '++input-area :object self :frame self :pos #'(lambda (f) (om-make-point (- (w f) (* (if allow-remove 2 1.2) S)) S)) :pick #'(lambda (f) (declare (ignore f)) (list (- S) (- S) S S)))) (when (allow-remove-inputs (object self)) (make-instance '--input-area :object self :frame self :pos #'(lambda (f) (om-make-point (- (w f) S) (* (if allow-add 2 1) S))) :pick #'(lambda (f) (declare (ignore f)) (list (- S) (- S) S S)))))) )) (defmethod om-draw-area ((area input-edit-area)) (let ((p (get-position area))) (om-with-fg-color (om-def-color :light-gray) (om-draw-circle (om-point-x p) (om-point-y p) 5 :fill t)))) (defmethod om-draw-area ((area ++input-area)) (unless (disabled-area area) (let ((p (get-position area))) (call-next-method) (om-with-fg-color (if (active area) (om-def-color :dark-red) (om-def-color :gray)) (om-with-line-size (if (active area) 2 1) (om-draw-line (om-point-x p) (- (om-point-y p) 2.5) (om-point-x p) (+ (om-point-y p) 2.5)) (om-draw-line (- (om-point-x p) 2.5) (om-point-y p) (+ (om-point-x p) 2.5) (om-point-y p))))))) (defmethod om-draw-area ((area --input-area)) (unless (disabled-area area) (let ((p (get-position area))) (call-next-method) (om-with-fg-color (if (active area) (om-def-color :dark-red) (om-def-color :gray)) (om-with-line-size (if (active area) 2 1) (om-draw-line (- (om-point-x p) 2.5) (om-point-y p) (+ (om-point-x p) 2.5) (om-point-y p))))))) (defmethod add-next-input ((boxframe OMBoxFrame)) (let ((box (object boxframe))) (cond ((next-optional-input box) (optional-input++ box)) ((next-keyword-input box) (keyword-input++ box)) (t nil)))) (defmethod click-in-area ((self ++input-area) boxframe) (let ((ed (editor (om-view-container boxframe)))) (store-current-state-for-undo ed) (add-next-input boxframe) t)) (defmethod click-in-area ((self --input-area) boxframe) (let ((box (object boxframe)) (ed (editor (om-view-container boxframe)))) (cond ((get-optional-inputs box) (store-current-state-for-undo ed) (optional-input-- box)) ((get-keyword-inputs box) (store-current-state-for-undo ed) (keyword-input-- box)) (t t)))) ;;;============================= ;;; RESIZE ;;;============================= (defclass resize-area (frame-area) ((p0 :accessor p0 :initform nil))) (defclass h-resize-area (resize-area) ()) (defclass v-resize-area (resize-area) ()) (defmethod h-resizable ((self t)) t) (defmethod v-resizable ((self t)) t) (defmethod resize-areas ((self OMBoxFrame)) (remove nil (list (when (and (h-resizable (object self)) (v-resizable (object self))) (make-instance 'resize-area :object self :frame self :pos #'(lambda (f) (om-make-point (- (w f) 8) (- (h f) 8))) :pick #'(lambda (f) (declare (ignore f)) (list 0 0 12 12)))) (when (h-resizable (object self)) (make-instance 'h-resize-area :object self :frame self :pos #'(lambda (f) (om-make-point (- (w f) 8) 16)) :pick #'(lambda (f) (list 0 0 12 (- (h f) 16))))) (when (v-resizable (object self)) (make-instance 'v-resize-area :object self :frame self :pos #'(lambda (f) (om-make-point 0 (- (h f) 8))) :pick #'(lambda (f) (list 0 0 (- (w f) 8) 12)))) ))) (defparameter *resize-handler* nil) (defun get-cursor-if-allowed (area cursor) (unless (container-frames-locked (om-view-container (frame area))) (om-get-cursor cursor))) (defmethod om-view-cursor ((self resize-area)) (get-cursor-if-allowed self :resize)) (defmethod om-view-cursor ((self h-resize-area)) (get-cursor-if-allowed self :h-size)) (defmethod om-view-cursor ((self v-resize-area)) (get-cursor-if-allowed self :v-size)) (defmethod resize-handle ((self resize-area) container frame pos) (let ((pp (om-add-points (p0 self) pos))) (om-set-view-size frame (om-borne-point (resize-frame-size self frame pp) (minimum-size (object frame)) (maximum-size (object frame)) )))) (defmethod resize-frame-size ((self resize-area) frame pos) pos) (defmethod resize-frame-size ((self h-resize-area) frame pos) (omp (om-point-x pos) (h frame))) (defmethod resize-frame-size ((self v-resize-area) frame pos) (omp (w frame) (om-point-y pos))) (defmethod click-in-area ((self resize-area) boxframe) (unless (container-frames-locked (om-view-container boxframe)) (setf (p0 self) (om-subtract-points (om-view-size boxframe) (om-mouse-position boxframe))) (select-box (object boxframe) t) (setf *resize-handler* self))) (defmethod om-click-release-handler ((self OMBoxFrame) pos) (when *resize-handler* (setf *resize-handler* nil) (let* ((box (object self)) (view (om-view-container self)) (size (om-view-size self))) (store-current-state-for-undo (editor view)) (omng-resize box (omp (if (scale-in-x-? box) (omng-w view (om-point-x size)) (om-point-x size)) (if (scale-in-y-? box) (omng-h view (om-point-y size)) (om-point-y size)))) ) (redraw-connections self))) (defmethod om-click-motion-handler ((self OMBoxFrame) pos) (if *resize-handler* (progn (resize-handle *resize-handler* (om-view-container self) self pos) (mapcar 'update-points (get-box-connections (object self))) (redraw-connections self) ) ;;; drag and drop (call-next-method))) ;;;============================= ;;; SHOW INSPECTOR BUTTON ;;; (not used) ;;;============================= (defclass get-info-area (frame-area) ()) (defmethod area-tt-text ((self get-info-area)) nil) ;"open inspector") ;;; info area is virtually disabled if the box is too small (defmethod enabled-area ((area get-info-area)) (>= (w (frame area)) 40)) (defmethod om-draw-area ((area get-info-area)) (let ((p (get-position area))) (when (and (active area) (enabled-area area)) (om-with-fg-color (om-def-color :gray) (om-draw-circle (+ 7 (om-point-x p)) (om-point-y p) 6 :fill t)) (om-with-fg-color (om-def-color :white) (om-draw-circle (+ 7 (om-point-x p)) (om-point-y p) 6 :fill nil)) (om-with-fg-color (om-def-color :white) (om-with-font (om-def-font :large-b) (om-draw-string (+ (om-point-x p) 5) (+ (om-point-y p) 4) "i")))))) (defmethod info-area ((self OMBoxFrame)) (list (make-instance 'get-info-area :object self :frame self :pos #'(lambda (f) (om-make-point 0 (/ (h f) 2))) :pick #'(lambda (f) (declare (ignore f)) (list 0 -8 16 8))) )) (defmethod click-in-area ((area get-info-area) boxframe) (when (enabled-area area) (patch-editor-set-window-config (editor boxframe) :inspector) (update-inspector-for-object (object boxframe)) )) ;;;============================= ;;; General Methods (OMBOXFRAME) ;;;============================= (defmethod set-frame-areas ((self t)) nil) (defmethod set-frame-areas ((self OMBoxFrame)) (let* ((box (object self)) (nin (length (inputs box))) (nout (length (outputs box))) (eia (input-edit-areas self)) (statesign-w 5) (extra-w (+ (* statesign-w 2) (if (and eia (inputs box) (or (> (length (inputs box)) 1) (< (box-w box) 40))) 10 0) ))) (setf (areas self) (append (mapcar #'(lambda (in) (setf (area in) (make-instance 'input-area :object in :frame self :pos #'(lambda (f) (om-make-point (round (+ statesign-w (* (- (w f) extra-w) (/ (1+ (* 2 (or (position in (inputs box)) 0))) (* 2 nin))))) +active-r+)) :pick '(-6 -15 6 4)))) (inputs box)) (mapcar #'(lambda (out) (setf (area out) (make-instance 'output-area :object out :frame self :pos #'(lambda (f) (om-make-point (round (+ statesign-w (* (- (w f) extra-w) (/ (1+ (* 2 (or (position out (outputs box)) 0))) (* 2 nout))))) (- (round (h f)) +active-r+) ;;; (would be better if H was already an integer...) )) :pick '(-6 -6 6 6)))) (outputs box)) (resize-areas self) ;(info-area self) eia )) (mapcar 'update-points (get-box-connections box)) (redraw-connections self) )) (defmethod make-frame-from-callobj ((self OMBox)) (let ((view (om-make-graphic-object (get-box-frame-class self) :position (omp (box-x self) (box-y self)) :object self :icon-id (get-icon-id self)))) (setf (frame self) view) (set-frame-areas view) (update-after-prop-edit view self) view)) (defmethod update-frame-connections-display ((self OMBoxFrame)) ; (print (mapcan 'connections (append (inputs (object self)) (outputs (object self))))) (mapc #'(lambda (c) (update-connection-display c (om-view-container self))) ;;; MAPCAN hangs here I don't know why. ;;; on Windows at least, when there are more than 1 connections ;;; works better with LOOP + APPEND (loop for io in (append (inputs (object self)) (outputs (object self))) append (connections io)) )) (defmethod fit-box-and-frame ((box OMBox) (frame OMBoxFrame)) (when (font-? (text-font box)) (om-set-font frame (font-font (text-font box)))) (let ((adjusted-size (om-borne-point (omp (box-w box) (box-h box)) (minimum-size box) (maximum-size box)))) (when (or (not (scale-in-x-? box)) (null (box-w box))) (setf (box-w box) (om-point-x adjusted-size))) (when (or (not (scale-in-y-? box)) (null (box-h box))) (setf (box-h box) (om-point-y adjusted-size))) (om-set-view-size frame (omp (if (scale-in-x-? box) (omg-w (om-view-container frame) (box-w box)) (box-w box)) (if (scale-in-y-? box) (omg-h (om-view-container frame) (box-h box)) (box-h box)))) (om-invalidate-view frame) (update-frame-connections-display frame) )) (defmethod update-after-prop-edit ((self OMBoxFrame) (object OMBox)) (fit-box-and-frame object self)) (defmethod update-to-editor ((self OMEditor) (from OMBox)) ;(print (list "update" self "from BOX" from)) (call-next-method) (update-default-view self)) ;;;=========================== ;;; DRAW ;;;=========================== (defmethod box-draw ((self t) (frame OMBoxFrame)) nil) (defmethod object-for-miniview ((self OMBox)) (get-box-value self)) (defmethod default-name ((self t)) nil) (defmethod get-icon-size ((self OMBox)) 16) (defmethod display-text-and-area ((self OMBoxFrame)) (let ((text (and (show-name (object self)) (or (name (object self)) (default-name (get-box-value (object self))))))) (when text (let ((font (or (box-draw-font (object self)) (om-get-font self)))) (multiple-value-bind (w h) (om-string-size text font) (let* ((icon-size (get-icon-size (object self))) (shift (if (and (equal (box-draw-icon-pos (object self)) :left) (< (h self) (+ icon-size h 12))) (+ icon-size 2) 0))) (values text (case (box-draw-text-align (object self)) (:center (+ shift (round (- (/ (- (w self) shift) 2) (/ w 2))))) (:right (- (w self) w 4)) (otherwise (+ shift 4))) (if nil ; (equal :left (icon-pos (object self))) 6 (- (h self) 10 h)) w (+ h 2)) )))))) (defmethod om-draw-contents ((self OMBoxFrame)) (om-trap-errors (om-with-clip-rect self 0 0 (w self) (h self) (boxframe-draw-contents self (object self))))) (defmethod draw-border ((self OMBox) x y w h) (let ((round (box-draw-roundness self)) (pensize (box-draw-border self))) (if (and round (plusp round)) (om-draw-rounded-rect x y w h :line (number-number pensize) :color (om-def-color :gray) :round (min (round h 2) round)) (om-draw-rect x y w h :line (number-number pensize) :color (om-def-color :gray)) ))) (defmethod draw-name-as-icon (box frame) nil) (defmethod boxframe-draw-contents ((self OMBoxFrame) (box OMBox)) (let ((icon-size (get-icon-size box)) (io-hspace 4) (color (box-draw-color box)) (font (box-draw-font box)) (round (box-draw-roundness box))) (om-with-fg-color (om-def-color :dark-gray) ;;; interior (unless (om-color-null-p color) (if (plusp round) (om-draw-rounded-rect 0 io-hspace (w self) (- (h self) (* 2 io-hspace)) :color color :fill t :round (min (round (h self) 2) round)) (om-draw-rect 0 io-hspace (w self) (- (h self) (* 2 io-hspace)) :color color :angles :round :fill t)) ) (when (selected box) (if (plusp round) (om-draw-rounded-rect 0 io-hspace (w self) (- (h self) (* 2 io-hspace)) :color (om-make-color-alpha (om-def-color :gray) 0.3) :fill t :round (min (round (h self) 2) round)) (om-draw-rect 0 io-hspace (w self) (- (h self) (* 2 io-hspace)) :color (om-make-color-alpha (om-def-color :gray) 0.3) :angles :round :fill t))) ;;; icon or main contents (or (box-draw box self) (if (icon-id self) (progn (unless (icon self) (setf (icon self) (om-load-picture-for-view (icon-id self) self))) (case (box-draw-icon-pos box) (:left (om-draw-picture (icon self) :x 2 :y 6 ; (- (h self) icon-size io-hspace) ; :w icon-size :h icon-size :w (- (h self) 12) :h (- (h self) 12) )) (:top (let ((w2 (min (w self) (- (h self) icon-size (* io-hspace 2))))) (om-draw-picture (icon self) :x (/ (- (w self) w2) 2) :y 7 :w w2 :h w2))) (otherwise nil))) (draw-name-as-icon box self)) ) ;;; name (om-with-clip-rect self 0 0 (w self) (- (h self) 8) (multiple-value-bind (text x y w h) (display-text-and-area self) (declare (ignore w h)) (when text (multiple-value-bind (tw th) (om-string-size text font) (declare (ignore tw)) (om-with-fg-color (box-draw-text-color box) (om-with-font font ;(om-draw-rect x y w h) (om-draw-string (max 2 x) (+ y th) text :selected nil :wrap (- (w self) 10) ;:align (box-draw-text-align box) ;; handled by display-text-and-area ) )))))) ;;; border (when (and (box-draw-border box) (plusp (box-draw-border box))) (draw-border box 0 io-hspace (w self) (- (h self) (* 2 io-hspace)))) )) ;;; in/outs etc. (mapcar #'(lambda (a) (om-draw-area a)) (areas self)) ) (defmethod draw-def-eval-once ((self OMBoxCall)) (> (length (get-out-connections self)) 1)) (defmethod draw-def-eval-once ((self OMPatchComponentBox)) nil) (defmethod boxframe-draw-contents ((self OMBoxFrame) (box OMBoxCall)) (call-next-method) (draw-eval-buttons self box 0 4 0 (- (h self) 15))) (defmethod draw-eval-buttons ((self OMFrame) (box OMBoxCall) x-lock y-lock x-lambda y-lambda) ;;; lambda button (when (lambda-state box) (om-draw-rounded-rect x-lambda y-lambda 13 11 :color (om-def-color :dark-gray) :round 2 :fill t) (om-with-fg-color (om-def-color :white) (case (lambda-state box) (:lambda (multiple-value-bind (char font) (om-lambda) (om-with-font font (om-draw-string (+ x-lambda 4) (+ y-lambda 9) (string char))))) (:reference (om-draw-line (+ x-lambda 6) (+ y-lambda 2) (+ x-lambda 6) (+ y-lambda 9)) (om-draw-line (+ x-lambda 6) (+ y-lambda 9) (+ x-lambda 3) (+ y-lambda 6)) (om-draw-line (+ x-lambda 6) (+ y-lambda 9) (+ x-lambda 9) (+ y-lambda 6))) (:box (om-draw-rect (+ x-lambda 3) (+ y-lambda 2) 7 7 :fill t)) ) )) ;;; lock button (let ((state-str nil) (bg-color (om-def-color :dark-gray))) (cond ((equal (lock-state box) :locked) (setf state-str "X")) ((and (equal (lock-state box) :eval-once) (not (get-pref-value :general :auto-ev-once-mode))) (setf state-str "1")) ((and (get-pref-value :general :auto-ev-once-mode) (draw-def-eval-once box)) (setf state-str "1" bg-color (om-gray-color 0.8 0.7)))) (when state-str (om-draw-rounded-rect x-lock y-lock 13 11 :color bg-color :round 2 :fill t) (om-draw-string (+ x-lock 3) (+ y-lock 9) state-str :font (om-def-font :gui :size 9) :color (om-def-color :white))) )) ;;;============================= ;;; CLIC&ACTIONS ;;;============================= (defmethod clickable-box ((self OMBoxFrame)) t) (defmethod allow-text-input ((self t)) nil) (defmethod edit-text-area ((self OMBoxFrame) position) (when (and (allow-text-input (object self)) (not (edit-lock (editor self)))) (multiple-value-bind (text x y w h) (display-text-and-area self) (if (and text (om-point-in-rect-p position x y w h)) ;;; EDIT THE NAME ? (multiple-value-bind (edittext action) (allow-text-input (object self)) (when text (let* ((container-view (om-view-container self))) (edit-text-in-patch edittext self container-view action (omp x y) (omp w h) :auto-resize t) t))) )))) (defmethod editable-on-click ((self t)) t) (defmethod om-view-click-handler ((self OMBoxFrame) position) (when (clickable-box self) ;;; if we're in multiple selection (SHIFT) or if the box is already selected: do not unselect all (when (and (not (active-area-at-pos self position)) (editable-on-click (object self)) ;; hooked by scoreboxes ! (selected (object self)) (not (om-add-key-down)) (not (om-shift-key-p))) (edit-text-area self position)) (let ((clicked-area (apply-in-area self 'click-in-area position))) (unless (and clicked-area (selected (object self))) ;; do not unselect (editor-box-selection (editor (om-view-container self)) (object self))) (or clicked-area self)))) ;;; handle boxframe click in multi-editor-view (defmethod om-view-click-handler :around ((self OMBoxFrame) position) (declare (ignore position)) (when (and (editor (om-view-container self)) (container-editor (editor (om-view-container self)))) (handle-multi-editor-click (om-view-container self) (container-editor (editor (om-view-container self))))) (call-next-method)) (defmethod om-view-cursor ((self OMBoxFrame)) (let ((aa (active-area-at-pos self (om-mouse-position self)))) (when aa (om-view-cursor aa)))) (defmethod click-in-area ((self frame-area) boxframe) self) (defmethod om-view-doubleclick-handler ((self OMBoxFrame) position) ;(or ;; edit area is a simple click on a selected box ;(and (selected (object self)) (not (om-command-key-p)) ; (edit-text-area self position)) (open-editor (object self)) t) (defun edit-text-in-patch (edittext frame container-view action pos size &key auto-resize multi-line) (let* ((box (object frame)) (textinput (om-make-di (if multi-line 'om-text-edit-view 'text-input-item) :text edittext :focus t :fg-color (om-def-color :dark-gray) :di-action #'(lambda (item) (let ((newtext (om-dialog-item-text item))) (om-end-text-edit item) (om-remove-subviews container-view item) (when (and action (> (length newtext) 0)) (when (not (string-equal newtext edittext)) (store-current-state-for-undo (editor container-view))) (funcall action box newtext)) (om-set-focus container-view) (unless (subtypep (type-of container-view) 'maquette-view) (let ((newsize (if auto-resize (om-min-point (om-max-point (om-view-size frame) (default-size box)) (maximum-size box)) (om-max-point (om-view-size frame) (minimum-size box)) ))) (om-set-view-size frame newsize) (setf (box-w box) (om-point-x newsize) (box-h box) (om-point-y newsize)) )) (mapcar 'update-points (get-box-connections box)) (redraw-connections frame) (om-invalidate-view frame) (report-modifications (editor container-view)) )) :begin-edit-action #'(lambda (item) (om-set-fg-color item (om-make-color 0.4 0 0)) ) :edit-action #'(lambda (item) (when multi-line ;;; the text is multi-line, but enter must still validate it (when (find #\Newline (om-dialog-item-text item)) (om-set-dialog-item-text item (remove #\Newline (om-dialog-item-text item))) (om-dialog-item-action item) )) (when auto-resize ;;; update the size of the box from the new text (let ((textsize (length (om-dialog-item-text item)))) (om-set-view-size item (om-make-point (list :character (+ 1 textsize)) (h item))) ))) :font (om-def-font :normal) :border t ;;; probably need to adjust these x/y values for different platforms... : :size (if multi-line (om-point-mv size :y -8 :x 0) (om-point-mv size :y 10 :x -10)) :position (if multi-line (om-point-mv (om-add-points (om-view-position frame) pos) :x 4 :y 9) (om-point-mv (om-add-points (om-view-position frame) pos) :x -2 :y 3)) ))) (om-add-subviews container-view textinput) ;;; if this is a multi-line, enter will erase the selected text and replace by a new line (om-set-text-focus textinput (if (and multi-line (> (length (om-text-to-lines edittext)) 1)) nil t)) )) ;;;============================= ;;; CONNECT ;;;============================= (defmethod click-in-area ((self output-area) boxframe) (if (om-command-key-p) (progn (eval-box-output-in-editor (editor (om-view-container boxframe)) (object boxframe) (position (object self) (outputs (object boxframe)))) t) (start-connection boxframe self))) (defvar *connection-handler* nil) (defmethod om-view-click-handler :around ((self patch-editor-view) position) (setf *connection-handler* nil) ;; in case a connection operation has aborted (call-next-method)) (defmethod start-connection ((self omboxframe) oa &optional after-fun) (unless (edit-lock (editor (om-view-container self))) (let* ((patchpanel (om-view-container self)) (init-pos-in-patch (om-convert-coordinates (get-position oa) self patchpanel)) (connection (om-make-graphic-object 'drag-line :position init-pos-in-patch :size (om-make-point 4 4)))) (setf *connection-handler* t) (om-init-temp-graphics-motion patchpanel init-pos-in-patch connection :min-move nil ;; so that the release action is called always => important ! :motion #'(lambda (panel pos) (om-set-view-size connection (om-subtract-points pos init-pos-in-patch)) (let ((target (om-find-view-containing-point panel pos))) (if (and target (not (equal target self))) (handle-connect-move target (om-convert-coordinates pos panel target) self oa) ))) :release #'(lambda (panel pos) (setf *connection-handler* nil) (let ((target (om-find-view-containing-point panel pos))) (when (and target (not (equal target self))) (let ((connected? (handle-connect-release target (om-convert-coordinates pos panel target) self oa patchpanel))) ;;; will not be called if handle-connect-release returns nil (when after-fun (funcall after-fun connected?)) ) ))) ) ))) (defparameter *last-active-frame* nil) (defun flush-active-area () (when (and *last-active-frame* (active-area *last-active-frame*)) (om-leave-area (active-area *last-active-frame*))) (setf *last-active-frame* nil)) (defmethod handle-connect-move ((self t) pos originframe output) (flush-active-area)) (defmethod handle-connect-move ((self omboxframe) pos originframe output) (let ((aa (active-area-at-pos self pos))) (when (and (active-area self) (not (equal aa (active-area self)))) (om-leave-area (active-area self))) (when (and aa (find aa '(input-area ++input-area) :test #'(lambda (x elt) (subtypep (type-of x) elt)))) (setf *last-active-frame* self) (om-enter-area aa) (setf (active-area self) aa)))) (defmethod handle-connect-release ((self t) pos originframe output get-out-connected-boxes) nil) ;;; CALLED WHEN THE CONNECTION ACTION IS RELEASED ;;; returns the new connection if ok (defmethod handle-connect-release ((self omboxframe) pos originframe output patchpanel) (let ((aa (active-area-at-pos self pos)) (editor (editor patchpanel))) (when aa (store-current-state-for-undo editor) (let ((new-connection (cond ((subtypep (type-of aa) 'input-area) (io-connect (object aa) (object output) (object editor) patchpanel)) ((subtypep (type-of aa) '++input-area) (add-next-input self) (io-connect (car (last (inputs (object self)))) (object output) (object editor) patchpanel)) ))) (when new-connection (report-modifications editor) (om-invalidate-view patchpanel) (redraw-connections self) new-connection) )))) ;;; tries to connect two boxes ;;; returns the new connection if OK (defmethod io-connect ((in box-input) (out box-output) patch panel) (let ((new-connection (omng-make-new-connection out in))) (when new-connection (loop for c in (connections in) do (omng-remove-element patch c)) (omng-add-element patch new-connection) (add-connection-in-view panel new-connection) new-connection))) (defmethod redraw-connections ((self OMBoxFrame)) (let ((connections (get-box-connections (object self))) (ed-view (om-view-container self))) (when ed-view (mapcar #'(lambda (c) (when (graphic-connection c) (setf (view (graphic-connection c)) ed-view))) connections)) (let ((all-points (loop for c in connections append (append (points c) (get-draw-points c))))) (mapcar #'update-graphic-connection connections) (when (and all-points (om-view-container self)) (om-invalidate-area (om-view-container self) (- (reduce 'min (mapcar 'om-point-x all-points)) 4) ;;; replace with list-min etc. pb when too many points (- (reduce 'min (mapcar 'om-point-y all-points)) 4) (+ (reduce 'max (mapcar 'om-point-x all-points)) 4) (+ (reduce 'max (mapcar 'om-point-y all-points)) 4) )) ))) (defmethod reset-frame-size ((frame omboxframe)) (om-set-view-size frame (omp (box-w (object frame)) (box-h (object frame))))) (defmethod update-frame-size-for-view ((frame omboxframe) (view t)) (let ((b (object frame))) (om-set-view-size frame (om-borne-point (omp (box-w b) (box-h b)) (minimum-size b) (maximum-size b) )))) ;;;============================= ;;; SPECIAL MOVE ;;;============================= ;;; this is for move actions to apply only on boxframes ;;; position is a symbolic position (defmethod move-frame-to-position ((self OMBoxFrame) (container-view om-view) position) (om-set-view-position self (om-round-point (omg-position container-view position))) (redraw-connections self)) (defmethod resize-frame-to-size ((self OMBoxFrame) (container-view om-view) size) (om-set-view-size self (om-round-point (omg-size container-view size))) (redraw-connections self)) ;;;============================= ;;; AUTO CONNECT ;;;============================= ;;; Several boxes are selected: the lower box's inputs are connected ;;; with the other boxes' outputs (defmethod is-lower (y1 y2 (editor patch-editor)) (> y1 y2)) (defun auto-connect-box (list-of-boxes editor view) (when list-of-boxes (let* ((y-sorted (sort list-of-boxes #'(lambda (y1 y2) (is-lower y1 y2 editor)) :key 'box-y)) (x-sorted (sort (cdr y-sorted) '< :key 'box-x)) (lower-box (car y-sorted)) ;(sorted-outputs (apply 'append (mapcar #'(lambda (frame) (outputs (object frame))) x-sorted))) (sorted-outputs (remove nil ;; some boxes have no output at all (e.g. comments !) (if (= 1 (length x-sorted)) (outputs (car x-sorted)) (mapcar #'(lambda (b) (car (outputs b))) x-sorted)))) (patch (object editor))) (when x-sorted ;; more than 1 box in the game (loop for i in (inputs lower-box) for o in sorted-outputs do (let* ((new-connection (omng-make-new-connection o i))) (when new-connection (loop for c in (connections i) do (omng-remove-element patch c)) (omng-add-element patch new-connection) (add-connection-in-view view new-connection) ))) (mapc #'(lambda (box) (redraw-connections (frame box))) list-of-boxes) (report-modifications editor) (om-invalidate-view view))) t)) ;;; Auto connects vertically (first in/outs) (defun auto-connect-seq (list-of-boxes editor view) (when list-of-boxes (let* ((y-sorted (sort list-of-boxes #'(lambda (y1 y2) (is-lower y1 y2 editor)) :key 'box-y)) (patch (object editor))) (loop for rest on y-sorted while (cadr rest) do (let* ((i (car (inputs (car rest)))) (o (car (outputs (cadr rest))))) (when (and i o) (let ((new-connection (omng-make-new-connection o i))) (when new-connection (loop for c in (connections i) do (omng-remove-element patch c)) (omng-add-element patch new-connection) (add-connection-in-view view new-connection)))))) (mapc #'(lambda (box) (redraw-connections (frame box))) list-of-boxes) (report-modifications editor) (om-invalidate-view view))) t) ;;;============================= ;;; EDIT INPUT OR MOVE A CONNECTION ;;;============================= ;(defmethod* test (a b &key c (d 9) e) ; :menuins '((1 (("b1" 4) ("b2" 5))) ; (3 (("d1" 8) ("d2" 9)))) ; :initvals '(1 2 3 8 5) ; d) (defmethod additional-box-attributes-names ((self OMBox)) nil) (defun key-to-menu (key box input) (if (listp key) (om-make-menu-comp (when key (append (if (find (car key) (additional-box-attributes-names box)) (list (om-make-menu-item "-- box attributes --" nil :enabled nil :selected nil))) (loop for k in key collect (key-to-menu k box input)) ))) (let ((selected (string-equal (name input) (string key)))) (if (and selected (get-input-menu box (name input))) ;;; it's a keyword which has a menu also for values (input-values-menu (string+ ":" (string-downcase key) " [select]") box input) ;;; just a normal menu item (om-make-menu-item (string+ ":" (string-downcase key)) (let ((currentkey key)) #'(lambda () (change-keyword input currentkey))) :enabled (or nil ; selected (equal key (box-free-keyword-name box)) (not (find (string key) (get-keyword-inputs box) :test 'string-equal :key 'name))) :selected selected ;; will not wok if all items are enabled... (?) ))))) ;;; Displays a menu for the keyword arguments of a function (defun show-keywords-menu (input box view) ; IF ALL THE ITEMS ARE ENABLED THE SELECTION DOESN'T WORK: MYSTERIOUS... ;(let ((fakeitem (when (= 1 (length (get-keyword-inputs box))) ; (list (om-make-menu-item "" nil :enabled nil :selected nil))))) (let ((menu (om-make-menu "keyword arguments" (loop for key in (get-all-keywords box) collect (key-to-menu key box input)) ;(list (key-to-menu (get-all-keywords box) box input)) ))) (om-open-pop-up-menu menu view) )) (defun input-values-menu (name box input) (om-make-menu name (loop for item in (get-input-menu box (name input)) ;;(cons '("" nil) (get-input-menu box (name input))) for i = 0 then (+ i 1) collect (let ((item-value (if (quoted-form-p (cadr item)) (eval (cadr item)) (cadr item)))) (om-make-menu-item (car item) #'(lambda () (set-value input item-value)) :enabled t :selected (equal (value input) item-value) )) ))) ;;; Displays a menu for the values of an input (defun show-input-val-menu (input box view) (let ((menu (input-values-menu "input val menu" box input))) (om-open-pop-up-menu menu view))) ;;; creates a new box with the current value of an input (defmethod popup-value-as-new-box ((self input-area) view &optional (connect t)) (let* ((new-box (omNG-make-new-boxcall 'value (omng-position view (om-add-points (om-convert-coordinates (get-position self) (frame self) view) (om-make-point -10 -40))) (value (object self)))) (patch (object (editor view)))) (store-current-state-for-undo (editor view)) (add-box-in-patch-editor new-box view) (move-box new-box (- (om-point-x (io-position-in-patch self)) (om-point-x (io-position-in-patch (area (first (outputs new-box)))))) 0) (when connect (io-connect (object self) (first (outputs new-box)) patch view)) )) (defmethod popup-value-as-new-box ((self output-area) view &optional (connect t)) (let* ((box (object (frame self))) (pos (position (object self) (outputs box)))) (output-value-as-new-box (if pos (nth pos (value box)) (value (object self))) view (om-add-points (om-convert-coordinates (get-position self) (frame self) view) (om-make-point 0 20)) (when connect (object self))))) (defun output-value-as-new-box (value view pos &optional (connect-to nil)) (multiple-value-bind (new-box new-connection) (make-new-box-with-instance value pos connect-to) (store-current-state-for-undo (editor view)) (let ((frame (add-box-in-patch-editor new-box view))) (move-box new-box (- (om-point-x pos) (om-point-x (io-position-in-patch (area (first (outputs new-box)))))) 0) (if new-connection (progn (omng-add-element (object (editor view)) new-connection) (add-connection-in-view view new-connection) (om-invalidate-view view)) (when (inputs new-box) (setf (lock-state new-box) :locked))) frame))) ;;; disconnects an input and reconnect somewhere else (defun reconnect-input-connection (connection patch) (when (graphic-connection connection) ;;; !!! the connection stays disabled even if there is no movement (setf (state (graphic-connection connection)) :disabled) (start-connection (frame (area (from connection))) (area (from connection)) #'(lambda (connected?) ;;; connected? is the new connection (if any) (if connected? (let () (setf (style connected?) (style connection) (color connected?) (color connection)) (update-graphic-connection connected?) (omng-remove-element patch connection) ) (setf (state (graphic-connection connection)) nil)) )))) (defmethod enter-input-value ((self input-area) view) (om-hide-tooltip view) (setf (temp-locked self) t) (let ((textinput (om-make-di 'text-input-item :text (format nil "~s" (value (object self))) :focus t :border t :fg-color (om-def-color :dark-gray) :di-action #'(lambda (item) (let ((text (om-dialog-item-text item))) (om-end-text-edit item) (om-remove-subviews view item) (let ((val (ignore-errors (read-from-string text)))) (when (quoted-form-p val) (setf val (eval val))) (set-value (object self) val)) (setf (temp-locked self) nil) (report-modifications (editor view)) (om-set-focus view))) :begin-edit-action #'(lambda (item) (om-set-fg-color item (om-make-color 0.4 0 0)) ) :edit-action #'(lambda (item) (let ((textsize (length (om-dialog-item-text item)))) (om-set-view-size item (om-make-point (list :character (1+ textsize)) 20)) )) :font (om-def-font :normal) :size (om-make-point 60 30) :position (om-add-points (om-convert-coordinates (get-position self) (frame self) view) (om-make-point -10 -12))))) (om-add-subviews view textinput) (om-set-text-focus textinput t) t)) ;;;===================== ;;; MAIN FUNCTION: CLICK ON INPUT ;;;===================== (defmethod click-in-area ((self input-area) boxframe) (let* ((input (object self)) (box (object boxframe)) (c (car (connections input))) (editorview (om-view-container boxframe))) (unless (edit-lock (editor editorview)) (if (subtypep (type-of input) 'box-keyword-input) ;;; KEYWORD INPUTS = SPECIAL (if (om-shift-key-p) (if (get-input-menu box (name input)) (show-input-val-menu (object self) (object boxframe) editorview) (popup-value-as-new-box self editorview) ) ;;; NO SHIFT (show-keywords-menu (object self) (object boxframe) editorview)) ;;; ELSE (NO KEYWORD) (if c ;;; IF CONNECTED (cond ((om-shift-key-p) ;;; shift + click = unconnect (let ((patch (object (editor editorview)))) (omng-remove-element patch c) (apply 'om-invalidate-area (cons editorview (graphic-area c))))) (t ;;; click = reconnect (let ((patch (object (editor editorview)))) (reconnect-input-connection c patch))) ) ;;; ELSE: NOT CONNECTED (cond ((om-shift-key-p) ;;; shift + click = show value as a box (popup-value-as-new-box self editorview)) ((get-input-menu box (name input)) ;;; there is a menu for this input: display (show-input-val-menu (object self) (object boxframe) editorview)) ;;; click = open a text edit to enter a value (t (enter-input-value self editorview)) ) ))) )) (defmethod om-get-menu-context ((self OMBoxFrame)) (let* ((position (om-mouse-position self)) (aa (active-area-at-pos self position))) (if aa (menu-in-area aa self) (box-menu-context (object self))))) (defmethod menu-in-area ((self t) boxframe) nil) (defmethod box-menu-context ((self t)) nil) (defmethod menu-in-area ((self io-area) boxframe) (let ((io (object self)) (editorview (om-view-container boxframe))) (list (list (om-make-menu-item "pop & connect value" #'(lambda () (popup-value-as-new-box self editorview t)) :enabled (and (can-popup-new-box-from-val editorview) (not (connections io)))) (om-make-menu-item "disconnect" #'(lambda () (mapc #'(lambda (c) (omng-remove-element (object (editor editorview)) c) (apply 'om-invalidate-area (cons editorview (graphic-area c)))) (connections io))) :enabled (connections io)) (om-make-menu-item (if (reactive (object self)) "set not reactive" "set reactive") #'(lambda () (setf (reactive io) (not (reactive io))) (update-reactive-state (box (object self))) (mapc #'(lambda (c) (apply 'om-invalidate-area (cons editorview (graphic-area c)))) (connections io)) )) )) )) ; (om-new-leafmenu "Picture" #'(lambda () (make-bg-pict self posi)))

Common Lisp

.lisp

cac-t-u-s/om-sharp

GPL-3.0

9/19/2024, 11:25:22 AM (Europe/Amsterdam)

c54f84bce788b68f01c09cc5bcf40ab5dffd71e09f77eef9feb1c89a444d4ba8

lisp-function.lisp

cac-t-u-s_om-sharp/src/visual-language/patch/lisp-function.lisp

;============================================================================ ; om#: visual programming language for computer-assisted music composition ;============================================================================ ; ; This program is free software. For information on usage ; and redistribution, see the "LICENSE" file in this distribution. ; ; This program 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. ; ;============================================================================ ; File author: J. Bresson ;============================================================================ (in-package :om) (defclass OMLispFunction (OMProgrammingObject) ((text :initarg :text :initform "" :accessor text) (error-flag :initform nil :accessor error-flag) )) (defmethod get-object-type-name ((self OMLispFunction)) "LispFun") (defmethod default-compiled-gensym ((self OMLispFunction)) (gensym "lispfun-")) (defclass OMLispFunctionInternal (OMLispFunction) () (:default-initargs :icon :lisp-f) (:metaclass omstandardclass)) (defparameter *default-lisp-function-text* '(";;; Edit a valid LAMBDA EXPRESSION" ";;; e.g. (lambda (arg1 arg2 ...) ( ... ))" "(lambda () (om-beep))")) (defmethod omNG-make-special-box ((reference (eql 'lisp)) pos &optional init-args) (omNG-make-new-boxcall (make-instance 'OMLispFunctionInternal :name (if init-args (format nil "~A" (car (list! init-args))) "my-function") :text *default-lisp-function-text*) pos init-args)) (defmethod decapsulable ((self OMLispFunction)) nil) (defmethod update-lisp-fun ((self OMLispFunction)) (compile-patch self) (loop for item in (references-to self) do (update-from-reference item))) (defmethod copy-contents ((from OMLispFunction) (to OMLispFunction)) (setf (text to) (text from)) to) ;; other causes of update-lisp-fun are below in the editor (defmethod compile-patch ((self OMLispFunction)) "Compilation of a lisp function" (handler-bind ((error #'(lambda (err) (om-beep-msg "An error of type ~a occurred: ~a" (type-of err) (format nil "~A" err)) (setf (compiled? self) nil) (setf (error-flag self) t) (abort err) ))) (setf (error-flag self) nil) (let* ((lambda-expression (read-from-string (reduce #'(lambda (s1 s2) (concatenate 'string s1 (string #\Newline) s2)) (text self)) nil)) (function-def (if (and lambda-expression (lambda-expression-p lambda-expression)) (progn (setf (compiled? self) t) `(defun ,(intern (string (compiled-fun-name self)) :om) ,.(cdr lambda-expression))) (progn (om-beep-msg "ERROR IN LAMBDA EXPRESSION!!") (setf (error-flag self) t) `(defun ,(intern (string (compiled-fun-name self)) :om) () nil))))) (compile (eval function-def)) ;(setf (compiled? self) t) ) )) ;============================================================================ ; Lisp Function as external file ;============================================================================ (defclass OMLispFunctionFile (OMPersistantObject OMLispFunction) () (:default-initargs :icon :lisp-f-file) (:metaclass omstandardclass)) (add-om-doctype :textfun "olsp" "Text (Lisp) Function") (defmethod object-doctype ((self OMLispFunction)) :textfun) (defmethod type-check ((type (eql :textfun)) obj) (let ((fun (ensure-type obj 'OMLispFunction))) (when fun (change-class fun 'OMLispFunctionFile) (setf (icon fun) :lisp-f-file)) fun)) ; For conversions (defmethod internalized-type ((self OMLispFunctionFile)) 'OMLispFunctionInternal) (defmethod externalized-type ((self OMLispFunction)) 'OMLispFunctionFile) (defmethod externalized-icon ((self OMLispFunction)) :lisp-f-file) (defmethod make-new-om-doc ((type (eql :lispfun)) name) (make-instance 'OMLispFunctionFile :name name :text *default-lisp-function-text*)) (defmethod save-document ((self OMLispFunctionFile)) (call-next-method) (update-lisp-fun self)) (defmethod omng-save-relative ((self OMLispFunctionFile) ref-path) `(:textfun-from-file ,(if (mypathname self) (omng-save (relative-pathname (mypathname self) ref-path)) (omng-save (pathname (name self)))))) (defmethod om-load-from-id ((id (eql :textfun-from-file)) data) (let* ((path (omng-load (car data))) (checked-path (and (pathname-directory path) ;; normal case (check-path-using-search-path path))) (lispfun (if checked-path (load-doc-from-file checked-path :textfun) ;;; no pathname-directory can occur while loading old patch abstractions from OM6 ;;; in this case we look for a not-yet-save file with same name in registered documents (let ((registered-entry (find (pathname-name path) *open-documents* :test 'string-equal :key #'(lambda (entry) (name (doc-entry-doc entry)))))) (when registered-entry (doc-entry-doc registered-entry))) ))) (unless lispfun (om-beep-msg "LISP-FUN FILE NOT FOUND: ~S !" path) (setf lispfun (make-instance 'OMLispFunctionFile :name (pathname-name path))) (setf (mypathname lispfun) path)) lispfun)) ;;;=================== ;;; LISP FUNCTION BOX ;;;=================== (defmethod special-box-p ((name (eql 'lisp))) t) (defclass OMBoxLisp (OMBoxAbstraction) ()) (defmethod get-box-class ((self OMLispFunction)) 'OMBoxLisp) (defmethod draw-patch-icon :after ((self OMBoxLisp) icon &optional (offset-x 0) (offset-y 0)) (when (error-flag (reference self)) (om-with-fg-color (om-def-color :dark-red) (om-with-font *box-label-font* (om-draw-string (+ offset-x (/ (box-w self) 2) -30) (+ offset-y 20) "Error !!"))))) ;;; OMLispFunction doesn't have OMIn boxes to buils the box-inputs from (defmethod create-box-inputs ((self OMBoxLisp)) (compile-if-needed (reference self)) (let ((fname (intern (string (compiled-fun-name (reference self))) :om))) (when (fboundp fname) (let ((args (function-arg-list fname))) (loop for a in args collect (make-instance 'box-input :name (string a) :box self :reference nil))) ))) ;;; OMLispFunction doesn't have OMOut boxes to buils the box-inputs from (defmethod create-box-outputs ((self OMBoxLisp)) (list (make-instance 'box-output :reference nil :name "out" :box self))) (defmethod update-from-reference ((self OMBoxLisp)) (let ((new-inputs (loop for i in (create-box-inputs self) for ni from 0 collect (if (nth ni (inputs self)) (let ((ci (copy-io (nth ni (inputs self))))) ;;keep connections, reactivity etc. (setf (name ci) (name i)) ;; just get the new name ci) i))) (new-outputs (loop for o in (create-box-outputs self) for no from 0 collect (if (nth no (outputs self)) (copy-io (nth no (outputs self))) o)))) ;;; remove orphan connections (loop for in in (nthcdr (length new-inputs) (inputs self)) do (mapc #'(lambda (c) (omng-remove-element (container self) c)) (connections in))) (set-box-inputs self new-inputs) (set-box-outputs self new-outputs) (set-frame-areas (frame self)) (om-invalidate-view (frame self)) t)) (defmethod display-modes-for-object ((self OMLispFunction)) '(:hidden :mini-view :value)) (defmethod draw-mini-view ((self OMLispFunction) box x y w h &optional time) (let ((di 12)) (om-with-font (om-def-font :small) (loop for line in (text self) for i = (+ y 18) then (+ i di) while (< i (- h 18)) do (om-draw-string (+ x 12) i line))))) ;;;=================== ;;; EDITOR ;;;=================== (defclass lisp-function-editor (OMDocumentEditor) ()) (defmethod object-has-editor ((self OMLispFunction)) t) (defmethod get-editor-class ((self OMLispFunction)) 'lisp-function-editor) ;;; nothing, e.g. to close when the editor is closed (defmethod delete-internal-elements ((self OMLispFunction)) nil) ;;; maybe interesting to make this inherit from OMEditorWindow.. (defclass lisp-function-editor-window (om-lisp::om-text-editor-window) ((editor :initarg :editor :initform nil :accessor editor))) (defmethod window-name-from-object ((self OMLispFunctionInternal)) (format nil "~A [internal Lisp function]" (name self))) (defmethod om-lisp::type-filter-for-text-editor ((self lisp-function-editor-window)) '("Lisp function" "*.olsp")) ;;; this will disable the default save/persistent behaviours of the text editor ;;; these will be handled following the model of OMPatch (defmethod om-lisp::save-operation-enabled ((self lisp-function-editor-window)) nil) (defmethod open-editor-window ((self lisp-function-editor)) (if (and (window self) (om-window-open-p (window self))) (om-select-window (window self)) (let* ((lispf (object self)) (edwin (om-lisp::om-open-text-editor :contents (text lispf) :lisp t :class 'lisp-function-editor-window :title (window-name-from-object lispf) :x (and (window-pos lispf) (om-point-x (window-pos lispf))) :y (and (window-pos lispf) (om-point-y (window-pos lispf))) :w (and (window-size lispf) (om-point-x (window-size lispf))) :h (and (window-size lispf) (om-point-y (window-size lispf))) ))) (setf (editor edwin) self) (setf (window self) edwin) (om-lisp::text-edit-window-activate-callback edwin t) ;; will (re)set the menus with the editor in place edwin))) (defmethod om-lisp::text-editor-window-menus ((self lisp-function-editor-window)) (om-menu-items (editor self))) (defmethod om-lisp::om-text-editor-modified ((self lisp-function-editor-window)) (touch (object (editor self))) (setf (text (object (editor self))) (om-lisp::om-get-text-editor-text self)) (report-modifications (editor self)) (call-next-method)) (defmethod om-lisp::update-window-title ((self lisp-function-editor-window) &optional (modified nil modified-supplied-p)) (om-lisp::om-text-editor-window-set-title self (window-name-from-object (object (editor self))))) (defmethod om-lisp::om-text-editor-check-before-close ((self lisp-function-editor-window)) (ask-save-before-close (object (editor self)))) (defmethod om-lisp::om-text-editor-resized ((win lisp-function-editor-window) w h) (when (editor win) (setf (window-size (object (editor win))) (omp w h)))) (defmethod om-lisp::om-text-editor-moved ((win lisp-function-editor-window) x y) (when (editor win) (setf (window-pos (object (editor win))) (omp x y)))) ;;; update-lisp-fun at closing the window (defmethod om-lisp::om-text-editor-destroy-callback ((win lisp-function-editor-window)) (let ((ed (editor win))) (editor-close ed) (update-lisp-fun (object ed)) (setf (window ed) nil) (setf (g-components ed) nil) (unless (references-to (object ed)) (unregister-document (object ed))) (call-next-method))) ;;; update-lisp-fun at loosing focus (defmethod om-lisp::om-text-editor-activate-callback ((win lisp-function-editor-window) activate) (when (editor win) (when (equal activate nil) (update-lisp-fun (object (editor win)))) )) ;;; called from menu (defmethod copy-command ((self lisp-function-editor)) #'(lambda () (om-lisp::text-edit-copy (window self)))) (defmethod cut-command ((self lisp-function-editor)) #'(lambda () (om-lisp::text-edit-cut (window self)))) (defmethod paste-command ((self lisp-function-editor)) #'(lambda () (om-lisp::text-edit-paste (window self)))) (defmethod select-all-command ((self lisp-function-editor)) #'(lambda () (om-lisp::text-select-all (window self)))) (defmethod undo-command ((self lisp-function-editor)) #'(lambda () (om-lisp::text-edit-undo (window self)))) ;(defmethod redo-command ((self lisp-function-editor)) ; #'(lambda () (om-lisp::text-edit-redo (window self)))) (defmethod font-command ((self lisp-function-editor)) #'(lambda () (om-lisp::change-text-edit-font (window self))))

Common Lisp

.lisp

cac-t-u-s/om-sharp

GPL-3.0

9/19/2024, 11:25:22 AM (Europe/Amsterdam)

87b086cbcb1bdd2edf9d892363a4ef8350e343888739616fe33d085d1a8ec981

box-abstraction.lisp

cac-t-u-s_om-sharp/src/visual-language/patch/box-abstraction.lisp

;============================================================================ ; om#: visual programming language for computer-assisted music composition ;============================================================================ ; ; This program is free software. For information on usage ; and redistribution, see the "LICENSE" file in this distribution. ; ; This program 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. ; ;============================================================================ ; File author: J. Bresson ;============================================================================ (in-package :om) (defclass OMBoxAbstraction (OMBoxCall) ((pre-delay :initarg :pre-delay :initform 0 :accessor pre-delay) (ready :initform t :accessor ready)) (:default-initargs :text-align :center :icon-pos :left) (:metaclass omstandardclass)) ;;; a tricky accessor for patch names :) (defmethod box-patch-name-access ((box OMBoxAbstraction) &optional (name nil name-provided-p)) (if name-provided-p ;;; SET (if (is-persistant (reference box)) ;;; don't do it if the path doesn't change! ;;; it could break the recursive-patch loading system ;;; by updating the patch reference (when (not (pathname-match-p (mypathname (reference box)) (pathname name))) (let ((patch (container box))) (when (editor patch) (store-current-state-for-undo (editor patch))) (let ((newpatch (and (probe-file name) (load-doc-from-file name :patch)))) (if newpatch (let ((oldpatch (reference box))) (release-reference oldpatch box) (setf (reference box) newpatch) (retain-reference newpatch box) (update-from-reference box) ) (progn (om-message-dialog (format nil "A document could not be loaded from ~S" name)) (update-inspector-for-object box)))))) ;;; Internal abstraction (let ((patch (container box))) (when (editor patch) (store-current-state-for-undo (editor patch))) (set-name (reference box) name)) ) ;;; GET (if (is-persistant (reference box)) (mypathname (reference box)) (name (reference box))) )) ;;; Note :file-name will be stored and saved as a property of teh file. ;;; This is a redundant information with the box reference's "mypathname" ;;; (but also an absoute path, while the reference will be saved relative) (defmethod get-properties-list ((self OMBoxAbstraction)) (add-properties-list (call-next-method) `(("Appearance" ((:display "View (m)" ,(display-modes-for-object (reference self)) display))) ("Abstraction" ( ,(if (is-persistant (reference self)) '(:filename "File name" :path box-patch-name-access) '(:name "Name" :string box-patch-name-access)) )) ("Sequencer" ,(append '((:pre-delay "Pre-delay (ms)" :number pre-delay)) (if (play-obj? (get-box-value self)) '((:show-markers "Show markers" :bool show-markers)))) )))) ;;; filename is redudant with the filename of the box reference ;;; it is also likely to become wrong if the reference moves ;;; the attribute is mostly useful as a proxy to change the linked reference ;;; from the inspector UI (defmethod excluded-properties-from-save ((self OMBoxAbstraction)) (append (call-next-method) '(:filename))) (defmethod object-name-in-inspector ((self OMBoxAbstraction)) (format nil "~A box" (get-object-type-name (reference self)))) (defmethod set-reactive ((self OMBoxAbstraction) val) (setf (ready self) nil) (call-next-method)) (defmethod initialize-box-value ((self OMBoxAbstraction) &optional value) (setf (ready self) nil) (call-next-method)) (defmethod omNG-make-new-boxcall ((reference OMProgrammingObject) pos &optional init-args) (let* ((box (make-instance (get-box-class reference) :name (if init-args (format nil "~A" (car init-args)) (name reference)) :reference reference))) (setf (box-x box) (om-point-x pos) (box-y box) (om-point-y pos) (box-h box) 60) (retain-reference reference box) box)) (defmethod get-icon-id ((self OMBoxAbstraction)) (icon (reference self))) (defmethod create-box-inputs ((self OMBoxAbstraction)) (when (reference self) ;;; temp inputs might have been created for non-finished abstraction boxes (e.g. loading recursive patches) (let* ((temp-ins (remove-if-not #'numberp (inputs self) :key #'reference)) (new-inputs (mapcar #'(lambda (in) (make-instance 'box-input :reference in :name (name in) :box self :value (eval (defval in)) :doc-string (doc in))) (sort (get-inputs (reference self)) '< :key 'index) ))) (when (> (length temp-ins) (length new-inputs)) (setf new-inputs (append new-inputs (nthcdr (length new-inputs) temp-ins)))) new-inputs))) (defmethod create-box-outputs ((self OMBoxAbstraction)) (when (reference self) ;;; when temp inputs have been created for non-finished abstraction boxes (e.g. loading recursive patches) (let ((temp-outs (remove-if-not #'numberp (outputs self) :key #'reference)) (new-outputs (mapcar #'(lambda (out) (make-instance 'box-output :reference out :name (name out) :box self :reactive (reactive self) :doc-string (doc out))) (sort (get-outputs (reference self)) '< :key 'index) ))) (when (> (length temp-outs) (length new-outputs)) (setf new-outputs (append new-outputs (nthcdr (length new-outputs) temp-outs)))) new-outputs))) ;;; artificially create temporary inputs for non-finished abstraction boxes (e.g. loading recursive patches) (defmethod gen-temp-nth-input ((self OMBoxAbstraction) n) (setf (inputs self) (append (inputs self) (loop for i from (length (inputs self)) to n collect (make-instance 'box-input :box self :reference i)))) (nth n (inputs self))) ;;; artificially create temporary outputs for non-finished abstraction boxes (e.g. loading recursive patches) (defmethod gen-temp-nth-output ((self OMBoxAbstraction) n) (setf (outputs self) (append (outputs self) (loop for i from (length (outputs self)) to n collect (make-instance 'box-output :box self :reference i)))) (nth n (outputs self))) (defmethod update-from-reference ((self OMBoxAbstraction)) (setf (name self) (name (reference self))) (call-next-method)) (defmethod om-copy ((self OMBoxAbstraction)) (let ((newbox (call-next-method))) (setf (box-w newbox) (box-w self) (box-h newbox) (box-h self)) (retain-reference (reference newbox) newbox) newbox)) (defmethod collect-all-containers ((patch OMPatch)) (let ((containers nil)) (loop for ref in (references-to patch) when (and (subtypep (type-of ref) 'OMBox) (not (find (container ref) containers))) do (setf containers (append containers (cons (container ref) (collect-all-containers (container ref)))))) containers)) ;;;======================= ;;; THE FOLLOWING BEHAVIOURS DIFFER BETWEEN INTERNAL- AND FILE-ABSTRACTION ;;;======================= ;;; closes editor / removes view (may still exist in the undo stack) (defmethod omng-delete ((box OMBoxAbstraction)) (let ((patch (reference box))) (when (find box (references-to patch)) (release-reference patch box) ;;; close/delete recursive only if this is an internal patch ;;; OR a persistant patch that has no outside reference and no open editor (unless (and (is-persistant patch) (or (get-outside-references patch) (editor patch))) ;;; same as closing the editor ;(loop for refb in (box-references-to patch) ; do (release-reference patch refb)) (delete-internal-elements patch) (unless (is-persistant patch) (close-editor patch)) ;; persistent patches may remain open ) ) t )) (defmethod allow-rename ((self OMBoxAbstraction)) (not (is-persistant (reference self)))) ;;; only internal does report to the container's editor (defmethod update-from-editor ((self OMBoxAbstraction) &key (value-changed t) (reactive t)) (declare (ignore value-changed reactive)) ;;; reactive is handled in a :around method (when (frame self) (reset-cache-display self) (om-invalidate-view (frame self))) (unless (is-persistant (reference self)) (report-modifications (editor (container self)))) (call-next-method)) (defmethod allow-text-input ((self OMBoxAbstraction)) (unless (is-persistant (reference self)) (values (name self) #'(lambda (box text) (declare (ignore box)) ;;; the box name shall be updated as well (set-name (reference self) text) (update-inspector-for-object self) )))) (defmethod internalize-abstraction ((self OMBox)) nil) (defmethod internalized-type ((self t)) (type-of self)) (defmethod copy-contents ((from t) (to t)) nil) (defmethod internalize-abstraction ((self OMBoxAbstraction)) (if (is-persistant (reference self)) (let* ((old-ref (reference self)) (new-ref (make-instance (internalized-type old-ref) :name (name old-ref)))) (close-editor old-ref) (copy-contents old-ref new-ref) (release-reference old-ref self) (setf (reference self) new-ref) (retain-reference new-ref self) (redraw-frame self)) (om-beep-msg "The ~A '~A' is already internal." (type-of (reference self)) (name (reference self))) )) (defmethod allowed-move ((box OMBoxAbstraction) (editor patch-editor)) (or (is-persistant (reference box)) ;; recursion (and (not (equal (reference box) (object editor))) ;; patch in itself (not (find (reference box) (collect-all-containers (object editor)))) ;;; patch in one of its own childs ))) ;;;=================== ;;; DISPLAY ;;;=================== (defmethod box-draw ((self OMBoxAbstraction) (frame OMBoxFrame)) (when (> (h frame) 36) (case (display self) (:mini-view (draw-mini-view (reference self) self 10 0 (- (w frame) 20) (h frame) nil)) (:value ;(draw-mini-view (get-box-value self) self 4 4 (- (w frame) 8) (- (h frame) 12) nil) ;(draw-mini-arrow 24 9 3 10 7 1) (draw-values-as-text self 0 0) ) (otherwise (let ((label (string-upcase (get-object-type-name (reference self))))) (om-with-font *box-label-font* (om-with-fg-color (om-make-color 0.6 0.6 0.6 0.5) (om-draw-string (- (/ (w frame) 2) (/ (om-string-size label *box-label-font*) 2)) (max 22 (+ 6 (/ (h frame) 2))) label))) )) )) (unless (icon frame) (setf (icon frame) (om-load-picture-for-view (icon (reference self)) frame))) (draw-patch-icon self (icon frame)) t) (defun draw-mini-arrow (ax ay b w h i) (om-with-fg-color (om-make-color 1 1 1) (om-draw-polygon (list (+ ax b) ay (+ ax b w) ay (+ ax b w) (+ ay h) (+ ax b w b) (+ ay h) (+ ax b (/ w 2)) (+ ay h 5) ax (+ ay h) (+ ax b) (+ ay h)) :fill t)) (om-with-fg-color (om-make-color .5 .5 .5) (om-draw-polygon (list (+ ax b) ay (+ ax b w) ay (+ ax b w) (+ ay h) (+ ax b w b) (+ ay h) (+ ax b (/ w 2)) (+ ay h 5) ax (+ ay h) (+ ax b) (+ ay h)) :fill nil)) (om-draw-string (+ ax 5) (+ ay 9) (format nil "~D" i) :font (om-def-font :normal-b) :color (om-make-color .5 .5 .5))) ;;; display reference instead of value (defmethod change-display ((self OMBoxAbstraction)) (when (visible-property (get-properties-list self) :display) (let ((next-mode (next-in-list (display-modes-for-object (reference self)) (display self)))) (set-display self next-mode)))) (defmethod draw-values-as-text ((self OMBox) &optional (offset-x 0) (offset-y 0)) (om-with-fg-color (om-def-color :gray) (om-with-font (om-def-font :normal-b) ;(om-draw-string 40 18 "values:") (loop for v in (or (value self) (make-list (length (outputs self)))) for y = (+ offset-y 18) then (+ y 16) for i = 1 then (+ 1 i) do (draw-mini-arrow (+ offset-x 24) (- y 9) 3 10 7 i) (om-draw-string (+ offset-x 45) y (format nil "~A" v))) ))) (defmethod draw-patch-icon ((self OMBoxAbstraction) icon &optional (offset-x 0) (offset-y 0)) (let* ((iconsize (if (is-persistant (reference self)) 22 16))) (om-draw-picture icon :x (+ 4 offset-x) :y (+ 6 offset-y) :w iconsize :h iconsize) )) (defmethod minimum-size ((self OMBoxAbstraction)) (multiple-value-bind (tw th) (om-string-size (name self) (box-draw-font self)) (om-make-point (round (+ 10 (max (+ 28 tw) (* (length (inputs self)) 10) (* (box-n-outs self) 10)))) (round (max th (if (is-persistant (reference self)) 36 28)))))) (defmethod maximum-size ((self OMBoxAbstraction)) (omp 200 200))

Common Lisp

.lisp

cac-t-u-s/om-sharp

GPL-3.0

9/19/2024, 11:25:22 AM (Europe/Amsterdam)

3b3cc7e6556b20a75f758e5de65e4cfeb1b3dca431a1d5fbb79ba179f8b0eb8c

in-out.lisp

cac-t-u-s_om-sharp/src/visual-language/patch/in-out.lisp

;============================================================================ ; om#: visual programming language for computer-assisted music composition ;============================================================================ ; ; This program is free software. For information on usage ; and redistribution, see the "LICENSE" file in this distribution. ; ; This program 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. ; ;============================================================================ ; File author: J. Bresson ;============================================================================ ;========================================================================= ; Managing inouts and outputs in patches ;========================================================================= (in-package :om) ;;;========================== ;;; IN/OUT BOXES ;;;========================== (defclass OMPatchIO (OMPatchComponent) ((doc :initform "" :accessor doc :initarg :doc) (index :initform nil :accessor index))) (defclass OMIn (OMPatchIO) ((defval :initform nil :accessor defval :initarg :defval) (in-symbol :initform nil :accessor in-symbol)) (:documentation "An input of the current patch.")) (defclass OMOut (OMPatchIO) () (:documentation "An output of the current patch.")) (defmethod get-inputs ((self OMPatch)) (sort (remove nil (loop for box in (boxes self) when (equal (type-of (reference box)) 'OMIn) ;; here we do not include the special inputs (thisbox, thissequencer etc.) collect (reference box))) '< :key #'(lambda (i) (or (index i) 0)))) (defmethod get-outputs ((self OMPatch)) (sort (remove nil (loop for box in (boxes self) when (subtypep (type-of (reference box)) 'OMOut) collect (reference box))) '< :key #'(lambda (o) (or (index o) 0)))) (defmethod omNG-make-new-boxcall ((reference OMPatchIO) pos &optional init-args) (let* ((box (make-instance (get-box-class reference) :name (name reference) :reference reference :icon-pos :top :text-align :center :color (make-color-or-nil :color (om-def-color :transparent) :t-or-nil t) :border 0)) (size (minimum-size box))) (setf (box-x box) (om-point-x pos) (box-y box) (om-point-y pos) (box-w box) (om-point-x size) (box-h box) (om-point-y size)) box)) ;;;========================== ;;; BOX ;;;========================== ;;; GENERAL SUPERCLASS (defclass OMInOutBox (OMPatchComponentBox) ()) ;;; other OMPatchComponentBox just save their box-symbol (defmethod save-box-reference ((self OMInOutBox)) (omng-save (reference self))) (defmethod h-resizable ((self OMInOutBox)) nil) (defmethod io-box-icon-color ((self t)) (om-def-color :black)) (defmethod related-patchbox-slot ((self OMInOutBox)) nil) (defmethod set-name ((self OMInOutBox) name) (setf (name (reference self)) name) (when (and (container self) (related-patchbox-slot self)) (loop for ref in (box-references-to (container self)) do (setf (name (nth (1- (index (reference self))) (funcall (related-patchbox-slot self) ref)) ) name))) (call-next-method)) (defmethod allow-text-input ((self OMInOutBox)) (values (name self) #'(lambda (box text) (set-name box text)))) (defmethod box-draw ((self OMInOutBox) frame) (let* ((size (om-make-point 20 16)) (pos (if (equal (box-draw-icon-pos self) :left) (om-make-point 0 (- (h frame) 24)) (om-make-point (round (- (w frame) (om-point-x size)) 2) 8)))) (om-with-fg-color (io-box-icon-color self) (om-draw-rect (+ (om-point-x pos) 3) (om-point-y pos) (- (om-point-x size) 6) (- (om-point-y size) 6) :fill t) (om-draw-polygon (list (om-point-x pos) (+ (om-point-y pos) (- (om-point-y size) 8)) (+ (om-point-x pos) (om-point-x size)) (+ (om-point-y pos) (- (om-point-y size) 8)) (+ (om-point-x pos) (/ (om-point-x size) 2)) (+ (om-point-y pos) (om-point-y size))) :fill t) ) (om-with-fg-color (om-def-color :white) (om-with-font (om-def-font :normal-b) (om-draw-string (- (+ (om-point-x pos) (/ (om-point-x size) 2)) 4) (if (equal (box-draw-icon-pos self) :left) 14 18) (number-to-string (index (reference self)))) )) t)) ;;;==================================== ;; SPECIFIC BOXES ;;;==================================== ;;;==================================== ;;; IN (GENERAL) (defclass OMInBox (OMInOutBox) ()) (defmethod box-n-outs ((self OMInBox)) 1) (defmethod io-box-icon-color ((self OMInBox)) (om-make-color 0.2 0.6 0.2)) (defmethod special-box-p ((name (eql 'in))) t) (defmethod get-box-class ((self OMIn)) 'OMInBox) (defmethod related-patchbox-slot ((self OMInBox)) 'inputs) (defmethod box-symbol ((self OMIn)) 'in) (defmethod special-item-reference-class ((item (eql 'in))) 'OMIn) (defmethod next-optional-input ((self OMInBox)) (not (inputs self))) (defmethod more-optional-input ((self OMInBox) &key name (value nil val-supplied-p) doc reactive) (declare (ignore name doc)) (unless (inputs self) (add-optional-input self :name "internal input value" :value (if val-supplied-p value nil) :doc "set box value" :reactive reactive) t)) (defmethod omNG-make-special-box ((reference (eql 'in)) pos &optional init-args) (let ((name (car (list! init-args))) (val (cadr (list! init-args)))) (let ((box (omNG-make-new-boxcall (make-instance 'OMIn :name (if name (string name) "in")) ; :defval val pos init-args))) (when val (add-optional-input box :name "internal input value" :value val :doc "set box value")) box))) (defmethod current-box-value ((self OMInBox) &optional (numout nil)) (if numout (return-value self numout) (value self))) ;;;=================================== ;;; OUT (defclass OMOutBox (OMInOutBox) ()) (defmethod box-n-outs ((self OMOutBox)) 0) (defmethod io-box-icon-color ((self OMOutBox)) (om-make-color 0.3 0.6 0.8)) (defmethod create-box-inputs ((self OMOutBox)) (list (make-instance 'box-input :name "out-value" :box self :value NIL :doc-string "Connect here"))) (defmethod special-box-p ((name (eql 'out))) t) (defmethod get-box-class ((self OMOut)) 'OMOutBox) (defmethod related-patchbox-slot ((self OMOutBox)) 'outputs) (defmethod box-symbol ((self OMOut)) 'out) (defmethod special-item-reference-class ((item (eql 'out))) 'OMOut) (defmethod omNG-make-special-box ((reference (eql 'out)) pos &optional init-args) (let ((name (car (list! init-args)))) (omNG-make-new-boxcall (make-instance 'OMOut :name (if name (string name) "out")) pos init-args))) ;;;==================================== ;; PATCH INTEGRATION ;;;==================================== (defmethod register-patch-io ((self OMPatch) (elem OMIn)) (unless (index elem) ;; for instance when the input is loaded, the index is already set (let ((inputs (remove elem (get-inputs self)))) (setf (index elem) (if inputs ;; index is +1 of the max existing indices (1+ (apply #'max (mapcar 'index inputs))) 1))))) (defmethod register-patch-io ((self OMPatch) (elem OMOut)) (unless (index elem) (setf (index elem) (length (get-outputs self))))) (defmethod unregister-patch-io ((self OMPatch) (elem OMIn)) (loop for inp in (get-inputs self) do (when (> (index inp) (index elem)) (setf (index inp) (1- (index inp)))))) (defmethod unregister-patch-io ((self OMPatch) (elem OMOut)) (loop for out in (get-outputs self) do (when (> (index out) (index elem)) (setf (index out) (1- (index out)))))) (defmethod omNG-add-element ((self OMPatch) (box OMInOutBox)) (call-next-method) (register-patch-io self (reference box)) ;(unless *loaading-stack* ;;; do not update if patch is being loaded: inputs are already OK (loop for item in (references-to self) do (update-from-reference item)) t) (defvar *erased-io* nil) (defmethod omng-remove-element ((self OMPatch) (box OMInOutBox)) (call-next-method) (unregister-patch-io self (reference box)) (setf *erased-io* (reference box)) (loop for item in (references-to self) do (update-from-reference item)) (setf *erased-io* nil))

Common Lisp

.lisp

cac-t-u-s/om-sharp

GPL-3.0

9/19/2024, 11:25:22 AM (Europe/Amsterdam)

b94ba4ae00b0f3e4dc29ff8d77ac301030c149c9f613e37b0a50f85aac0aeecd

special-boxes.lisp

cac-t-u-s_om-sharp/src/visual-language/boxes/special-boxes.lisp

;============================================================================ ; om#: visual programming language for computer-assisted music composition ;============================================================================ ; ; This program is free software. For information on usage ; and redistribution, see the "LICENSE" file in this distribution. ; ; This program 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. ; ;============================================================================ ; File author: J. Bresson ;============================================================================ ;=============================================================================== ; SPECIAL BOXES ; BUT STILL 'FUNCTIONS' ;=============================================================================== (in-package :om) ;;;-------------------------- ;;; SEQ: SEQUENCE OPERATIONS ;;;-------------------------- ;;; !! todo check in/outs with undo (defmethod* seq ((op t) &rest op+) :numouts 1 :initvals '(nil) :indoc '("something to do" "something else to do") :icon :seq :doc "Evaluates sequentially a series of values, functions or subpatches. Accepts many optional inputs as needed. The outputs correspond to each successive inputs. To get the result of the nth item connected to the sequence box after the sequential evaluation, evaluate or connect the nth output (all the inputs will be evaluated anyway). !! Mind using this box in 'eval-once' mode when connected to several other boxes." (values-list (cons op op+))) (defclass OMBoxSeqCall (OMGFBoxcall) ()) (defmethod boxclass-from-function-name ((self (eql 'seq))) 'OMBoxSeqCall) ;;; shortcut (compatibility) (defmethod special-box-p ((name (eql 'sequence))) t) (defmethod omNG-make-special-box ((reference (eql 'sequence)) pos &optional init-args) (omNG-make-new-boxcall (fdefinition 'seq) pos init-args)) (defmethod add-optional-input ((self OMBoxSeqCall) &key name value doc reactive) (declare (ignore value doc reactive)) (call-next-method) (set-box-outputs self (append (outputs self) (list (make-instance 'box-optional-output :name (format nil "~A~D" name (length (outputs self))) :box self :doc-string (get-input-doc self name))))) ;(setf (lock-state self) :eval-once) (update-inspector-for-object self)) (defmethod remove-one-optional-input ((self OMBoxSeqCall)) (when (call-next-method) (remove-one-output self (car (last (outputs self)))))) ;;;------------------------------------------ ;; SPLIT A LIST in ITS OUTPUTS ;;;------------------------------------------ (defmethod function-changed-name ((reference (eql 'list-elements))) 'split) (defmethod* split ((list list) &rest add-output) :initvals '(nil) :indoc '("a list") :doc "Returns the elements of the list on different ouputs (up to 50 elements). Use > and < to add/remove outputs. !! It is advised to use this box in mode 'eval once' in order to avoid repeated computations of the connected input. " :icon 'list :numouts 1 (values-list (first-n list 50))) (defclass OMBoxSplit (OMGFBoxcall) ()) (defmethod boxclass-from-function-name ((self (eql 'split))) 'OMBoxSplit) (defmethod boxcall-value ((self OMBoxSplit)) (values-list (first-n (omNG-box-value (car (inputs self))) (length (outputs self))))) (defmethod allow-add-inputs ((self OMBoxSplit)) (< (length (outputs self)) 50)) (defmethod allow-remove-inputs ((self OMBoxSplit)) (> (length (outputs self)) 1)) ;; on this special box adding an input actually adds an ouput... (defmethod more-optional-input ((self OMBoxSplit) &key name value doc reactive) ;;; no checks (declare (ignore name value doc reactive)) (add-optional-input self) t) (defmethod add-optional-input ((self OMBoxSplit) &key name value doc reactive) (declare (ignore name value doc reactive)) (set-box-outputs self (append (outputs self) (list (make-instance 'box-optional-output :name (format nil "out~D" (length (outputs self))) :box self)) )) (update-inspector-for-object self) t) (defmethod remove-one-optional-input ((self OMBoxSplit)) (when (get-optional-inputs self) (remove-one-output self (car (last (outputs self)))))) ;; hack: all inputs (actually, ouputs) can be removed as "optional" (defmethod get-optional-inputs ((self OMBoxSplit)) (cdr (outputs self))) (defmethod save-outputs? ((self OMBoxSplit)) t) (defmethod restore-outputs ((self OMBoxSplit) outputs) (when (outputs self) (setf (outputs self) (list (car (outputs self))))) (dotimes (o (length (cdr outputs))) (add-optional-input self)) (call-next-method)) (defmethod add-args-to-box ((box OMBoxSplit) args) (let ((n (if (numberp (car args)) (car args) 2))) (dotimes (i (- n (length (outputs box)))) (add-optional-input box)) ;;(setf (lock-state box) :eval-once) )) ;;;--------------------------------------------------------------------- ;; HUB: PROXY TO USE THE SAME (UNDEFINED) VALUE AT DIFFERENT OUTPUT PORTS ;;;--------------------------------------------------------------------- ;;; todo: allow several inputs, too => all return the same ;; It is advised to use this box in mode 'eval once' in order to avoid useless computations. (defmethod* hub (value &rest add-output) :initvals '(nil) :indoc '("anthing") :doc "A patching utility, returning the same value to all its outputs. Use > and < to add/remove outputs. " :icon 'hub :numouts 1 value) (defclass OMBoxHub (OMBoxSplit) ()) (defmethod boxclass-from-function-name ((self (eql 'hub))) 'OMBoxHub) (defmethod boxcall-value ((self OMBoxHub)) (values-list (make-list (length (outputs self)) :initial-element (omNG-box-value (car (inputs self)))))) (defmethod gen-code-for-call ((self OMBoxHub) &optional args) `(values-list (make-list ,(length (outputs self)) :initial-element ,(gen-code (car (inputs self)))))) ;;;------------------------ ;;; DEFAULT VALUE UTIL ;;;------------------------ (defmethod* default (in default-value) :icon nil :doc "Returns the value <in> or <default-value> if <in> is NIL. Note: This is equivalent to the Lisp OR logical operator. " (or in default-value)) (defclass OMDefBoxCall (OMGFBoxcall) ()) (defmethod boxclass-from-function-name ((self (eql 'default))) 'OMDefBoxCall) (defmethod boxcall-value ((self OMDefBoxCall)) (let* ((input (omNG-box-value (car (inputs self)))) (def-value (omNG-box-value (cadr (inputs self))))) (set-name self (format nil "default: ~A" def-value)) (or input def-value)))

Common Lisp

.lisp

cac-t-u-s/om-sharp

GPL-3.0

9/19/2024, 11:25:22 AM (Europe/Amsterdam)

239371bcec2686fbb5167b65ef97a116ea06515022084df736576df919cfbe5a

global.lisp

cac-t-u-s_om-sharp/src/visual-language/boxes/global.lisp

;============================================================================ ; om#: visual programming language for computer-assisted music composition ;============================================================================ ; ; This program is free software. For information on usage ; and redistribution, see the "LICENSE" file in this distribution. ; ; This program 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. ; ;============================================================================ ; File author: J. Bresson ;============================================================================ ;;; A simplified version of the "global variable" system ;;; Global variables are identified by a unique symbol/name (just like in Lisp!) (in-package :om) ;;; OMGlobalVar is actually not really used: ;;; the name of the OMGlobalBox refers to a Lisp global. (defclass OMGlobalVar (OMPatchComponent) () (:documentation "A box holding the value of a global variable. Use it at different places to set and share some value across the environment.")) (defclass OMGlobalBox (OMPatchComponentBox) ()) (defmethod special-box-p ((ref (eql 'global))) t) (defmethod get-box-class ((ref OMGlobalVar)) 'OMGlobalBox) (defmethod box-symbol ((self OMGlobalVar)) 'global) (defmethod special-item-reference-class ((item (eql 'global))) 'OMGlobalVar) (defmethod omNG-make-special-box ((reference (eql 'global)) pos &optional init-args) (let* ((name (car (list! init-args))) (var (make-instance 'OMGlobalVar :name (if name (string name) (string (gensym "VAR")))))) (omNG-make-new-boxcall var pos))) (defmethod box-draw ((self OMGlobalBox) frame) (om-with-clip-rect frame 0 0 (- (w frame) 4) (- (h frame) 8) (om-with-font (om-make-font "Arial" 12 :style '(:bold)) (om-with-fg-color (om-make-color 0.6 0.6 0.6 0.5) (om-draw-string 4 16 "GLOBAL")) ))) (defmethod create-box-outputs ((self OMGlobalBox)) (list (make-instance 'box-output :box self :value nil :name "value"))) (defmethod next-optional-input ((self OMGlobalBox)) (zerop (length (inputs self)))) (defmethod more-optional-input ((self OMGlobalBox) &key name value doc reactive) (declare (ignore name doc)) (add-optional-input self :name "value" :value value :reactive reactive) t) (defmethod allow-rename ((self OMGlobalBox)) t) (defmethod allow-text-input ((self OMGlobalBox)) (unless (is-persistant (reference self)) (values (name self) #'(lambda (box text) ;;; the box name shall be updated as well (set-name box text) )))) ;;;======================== ;;; GLOBAL VAR BEHAVIOUR ;;;======================== (defmethod initialize-instance :after ((self OMGlobalBox) &rest args) (when (name self) (let ((sym (intern (string-upcase (name self))))) (unless (boundp sym) (om-print-format "Defining global variable: ~A" (list sym)) (eval `(defvar ,sym ',(car (value self)))) )))) (defmethod set-name :after ((self OMGlobalBox) new-name) (let ((sym (intern (string-upcase (name self))))) (unless (boundp sym) (om-print-format "Defining global variable: ~A" (list sym)) (eval `(defvar ,sym ',(car (value self)))) (set-name (reference self) new-name) ))) (defmethod set-value :after ((self OMGlobalBox) new-val) (when (name self) ;;; not always the case at this moment (e.g. at loading the box) (let ((sym (intern (string-upcase (name self))))) (eval `(setf ,sym ',(car new-val))) ))) (defmethod read-value ((self OMGlobalBox)) (let ((sym (intern (string-upcase (name self))))) (setf (value self) (list (eval sym))) (car (value self)))) (defmethod omng-save ((self OMGlobalBox)) (read-value self) (append (call-next-method) (list (save-value self)))) (defmethod boxcall-value ((self OMGlobalBox)) (when (and (car (inputs self)) (connections (car (inputs self)))) (let ((val (omNG-box-value (car (inputs self))))) (set-value self (list val)) )) (read-value self)) (defmethod gen-code-for-call ((self OMGlobalBox) &optional args) (let ((sym (intern (string-upcase (name self))))) (if (and (car (inputs self)) (connections (car (inputs self)))) `(setf ,sym ,(gen-code (car (inputs self)))) sym) ))

Common Lisp

.lisp

cac-t-u-s/om-sharp

GPL-3.0