random-exprs.rkt

#lang racket
(provide exprs)
(define exprs
  '((let ((d1 #\U0005C522)) -1)
    (cond
      ((cond
         (#t #t)
         (2 #f)
         (#\℥ (if 2 (if #f 8 #t) -1))
         (#f (if #f (if #\U00033DA3 #f #\U000129A4) (- #f)))
         ((let ((e1
                 (sub1
                  (cond
                    (-2 #\ڮ)
                    (#t #t)
                    (#f (if #f (char->integer -1) #\U0004A191))
                    ((cond
                       ((- (if #t #t #f)) (if (abs 6) 2 (add1 #\U0008A837)))
                       ((- (cond (else #t))) (- #\谖))
                       ((if -3 (if #f #f #f) (cond (-2 #\ᑱ) (else #\U0007584E)))
                        -5)
                       (#\鶪 (if #t (cond (else #t)) 1))
                       ((cond
                          ((add1 #t)
                           (cond
                             (#f #t)
                             (3 #f)
                             (#f #f)
                             (#\鉰 #f)
                             (#\廽 #\U000FE043)
                             (else #t)))
                          (else (if #f -1 #\U000CD929)))
                        -3)
                       (#f #f)
                       ((if #f (abs #t) #\U000A15DF)
                        (cond
                          ((cond
                             (#\菀 -9)
                             (#t #t)
                             (#t #t)
                             (#t #\U0007DB03)
                             (4 16)
                             (else #f))
                           #f)
                          (#f #f)
                          (else 1)))
                       (#\U00067FFB
                        (cond
                          ((cond
                             (#t -1)
                             (#\U0008250F -3)
                             (#f #\堪)
                             (#\쐐 #t)
                             (#\䊊 #f)
                             (-2 #t)
                             (#t #f)
                             (else #\꾫))
                           #f)
                          (else (integer? #t))))
                       (-4 #f)
                       ((zero? #f) #\U0005ABDD)
                       (#f (char->integer #t))
                       (#t 5)
                       (else #\U000467D5))
                     #f)
                    (#t #\书)
                    ((cond
                       ((boolean? #t) (cond (#\ꆧ #t) (else #f)))
                       (#\U000FD2D5 #\U0008AAB3)
                       (else 1))
                     #\뵷)
                    (else #t)))))
            (let ((c1 #t)) c1))
          (cond (else 260)))
         (#f #f)
         (#t -2)
         (#t (let ((k0 (cond (#t #f) (#\糛 #f) (else -3)))) (abs k0)))
         (else (integer? #t)))
       #\U000C5307)
      ((- #\U0009D7A1) (integer? #\䐴))
      (2 #\U000F7930)
      (#f (let ((f2 (if 3 1 (cond (#t #t) (else #t))))) #\鋑))
      (#\噾 5)
      (#\U00052A2F #t)
      ((let ((p1 #f)) #t) #\ڟ)
      (-5 #\ᝑ)
      (#f (if (cond (else (let ((i2 #\痮)) #\鷘))) #f -4))
      ((abs #\U0004E846) 17)
      (#\U000CAFDE
       (cond
         ((cond
            (#t #\Ỳ)
            ((char? #f) #t)
            ((char? -1) #\滏)
            ((let ((r2 #f)) #f)
             (cond
               (#t #f)
               (#\듻
                (cond
                  ((cond
                     ((cond
                        ((cond
                           (1 -32)
                           (-3 -2)
                           (-4 -2)
                           (#\U00046132 -1)
                           (#\ᢷ #f)
                           (#\U000DB1E1 #t)
                           (else #\؉))
                         (if #f #f -1))
                        (0 (sub1 #t))
                        (#f (cond (1 #f) (#f #\ቊ) (#f 2) (else #f)))
                        (#\⸋
                         (cond (#f #t) (#f #\U0005A306) (-1 #t) (3 #\县) (else #t)))
                        (-2
                         (cond
                           (#\쌙 #f)
                           (#f #\U000D3350)
                           (0 #\쨀)
                           (#t -2)
                           (#f -2)
                           (#t -1)
                           (else #\U00095474)))
                        (else (if 1 #t -2)))
                      (abs (if -2 #f #t)))
                     (2 #\섅)
                     (else
                      (cond
                        (-2 (if #\溍 #t #\킒))
                        (-5 #t)
                        (#\Ꞑ (if 1 #\U00079310 #\섖))
                        (else (cond (#\U0009984A #t) (else #\⭖))))))
                   (if (sub1 #f) #\U000BD571 8))
                  (else (char->integer #f))))
               (-2048 #f)
               (#\U000719B4 #f)
               (#f #f)
               (#t #t)
               (#\U00053A2B 3)
               (else #t)))
            (#f (cond (#\氼 #t) (#f #\甑) (#f #t) (2 #f) (else #f)))
            (#\耗 #t)
            (#t (- #f))
            ((let ((o0 1)) o0) (let ((v0 #t)) #f))
            (-1 (if #t #\U000DCBEF -2))
            ((char? #\놖) #\U000EF9EA)
            ((integer->char #\븴) 64)
            (else (cond (else 4))))
          #f)
         (-8 #f)
         (#f 5)
         (#f #t)
         (else 1)))
      (#\U0005E7B4 4)
      (1 #\哊)
      (#t 3)
      (-1 (integer? #t))
      ((integer? (abs (zero? #f))) #t)
      (#\U00048688
       (cond
         (#\弅 -2)
         ((if #\篿 (- (if #\ᒤ (if #t #f #t) (integer->char #\U00106581))) #\阯)
          (if #t
              (cond (#f #f) (#\U000AE168 (if 4 #\U0006E108 #t)) (else -3))
              (char? #t)))
         (#f (if (add1 #\U00060DA2) (sub1 -1) (let ((t1 #f)) #\U0010D457)))
         ((cond
            (#f
             (if #\U0004F8CC
                 #f
                 (cond
                   (#t
                    (cond
                      (6 0)
                      ((if -3 (cond (#t #f) (else -4)) -5)
                       (cond ((abs #f) #\辴) (#\夵 (cond (else #t))) (else 4)))
                      (#f (cond ((if 4 #t #t) #f) (else (if 2 1 #f))))
                      (-2 #t)
                      ((cond (else #t)) 2)
                      (else (if #t #t #f))))
                   (#\擾 (integer->char (integer->char #t)))
                   (16 -4)
                   ((cond
                      ((if -16 1 #f) (add1 #\U000160D5))
                      ((cond
                         ((integer->char #f) (abs #\U000F8F87))
                         (#f #\U000ED0B2)
                         (#f (zero? 256))
                         ((cond
                            (4 #\ṻ)
                            (#\U000E517D #f)
                            (#t -32)
                            (#f #f)
                            (#\U00019CC5 #\敆)
                            (#\U000AB976 #f)
                            (#f #f)
                            (#\묏 4)
                            (else #\U000A7896))
                          (if #f #\𐄞 #f))
                         ((if #f #t #\뽣) #f)
                         (#f (if #f #f #f))
                         (else (char? #f)))
                       #t)
                      (0 #\覆)
                      ((add1 (if #f #t #\仴)) (cond (#\U00083181 2) (else #f)))
                      (#f #t)
                      ((cond
                         (#\U00015ABF #t)
                         (#\껑 #\䝘)
                         ((integer? -1) -1)
                         (-1 (cond (#t 8) (#f #\𑆯) (else #\U000474A1)))
                         ((if #\U0009F467 #t #\U00073758) #t)
                         ((abs #f) (boolean? #f))
                         ((cond (#f 1) (#f #f) (#\U000938F9 #f) (#f -5) (else -1))
                          (if #\캠 -16 17))
                         (#\ᛄ #t)
                         ((if -4 #\邞 -1) #\쐪)
                         ((if #f #\U00078CC2 -1) (- #f))
                         ((cond
                            (-2 #\U000B73AE)
                            (#f #t)
                            (#\闇 #f)
                            (#\銪 #f)
                            (#t -2)
                            (#\颟 #t)
                            (else #t))
                          #t)
                         (#t #f)
                         ((if #t #f -1) -2)
                         (1 #f)
                         ((cond (#\U00041CA2 2) (7 #t) (-259 #f) (else #f)) #f)
                         (else #\U000C43B7))
                       #\U000AAB14)
                      ((if (if #\U00051B5B #t #t) -3 1) 2)
                      ((if 2 #\ⴌ -4)
                       (if (cond (else #f)) (cond (#t #\傿) (else #\U000E592C)) #\湀))
                      (#\U00081610 #\U000D444F)
                      (-5 #\埿)
                      (#t #\𧙓)
                      (#\矈 (char? (cond (#t #\蟾) (#f #f) (else 2))))
                      (#\U000354A6 #f)
                      ((cond
                         ((- -3) -3)
                         (2 #\ᮉ)
                         ((zero? 1) #t)
                         ((- 8) (- #\U000D6819))
                         ((cond (#f #f) (else #t)) (if 4 #\U000D6C65 #f))
                         ((cond (#t #f) (#\㳿 #f) (else #\瞆)) 8)
                         ((cond (#\U0009F5C4 0) (4 #\U00039670) (else 20)) 5)
                         ((cond (#f #f) (#f #\㒢) (else #f)) #\U000DA770)
                         (#\U00071BF2 #\U000C2A15)
                         (2 #f)
                         (6 (cond (#t #f) (#\U000978FC #f) (#t #t) (else -2)))
                         (#\U0001CDE3
                          (cond
                            (2 #f)
                            (#\U000F5CD8 1)
                            (#f #\U00069782)
                            (#\U0004FA1A #\U0009B0D1)
                            (else #t)))
                         (#\U0004D4DE #\U00016FC9)
                         (#\ꨳ #t)
                         ((- #\⥉) -2)
                         (1 #\প)
                         (#f -1)
                         (else #f))
                       (if #\U000BAD74 #f (if #\U000BE12D -1 -8)))
                      (#\𤡦 (integer->char (if 3 #\⁕ #\U000D5BDB)))
                      (#f (zero? #t))
                      ((abs (add1 #\쿠))
                       (abs (cond (#f #t) (#t #t) (else #\U000897CE))))
                      (#\弎
                       (cond
                         ((cond
                            (#t #\U000E42C4)
                            (#t #\U00010739)
                            (#t #f)
                            (3 #\𡯚)
                            (else #\昨))
                          (cond (else #t)))
                         (else
                          (cond
                            (-3 #f)
                            (#\螣 #\莁)
                            (#t 34)
                            (#f #f)
                            (#\U000914A7 #f)
                            (#t -2)
                            (-1 #f)
                            (#\蛫 #f)
                            (#f #\댫)
                            (#f #t)
                            (else #t)))))
                      (#\U000B3A7A
                       (cond
                         (#\误 (sub1 #\膀))
                         ((if #f #f #t) #f)
                         (#t #f)
                         (else (if 3 #t #\U0008891F))))
                      ((if #f
                           (cond
                             (0 #t)
                             (5 #\U0007DD2B)
                             (2 #t)
                             (#f #\U000D3925)
                             (#\㪌 #f)
                             (#t #f)
                             (#\駈 #f)
                             (-1 #t)
                             (-2 0)
                             (#\U0001A832 #\魫)
                             (else #t))
                           #t)
                       #f)
                      (#\U000758F4
                       (if (integer->char #\U000D3CE2) (cond (else 1)) #t))
                      (#f #t)
                      (#f (if #f 2 #t))
                      (#f
                       (if (char? #\U0009CCA0)
                           (if #\U00084B2A #f #f)
                           (cond (-2 #t) (#f #f) (else #f))))
                      (#f #t)
                      (0
                       (cond
                         (#f (cond (#\해 #f) (else #f)))
                         (4 (if 2 #t #t))
                         (else -2)))
                      ((cond
                         (#t (if #t #t #t))
                         (#t
                          (cond (#t #\杶) (#f #\엨) (#\U00017B87 #f) (#f #f) (else #f)))
                         (1 (cond (#f -3) (#f 17) (#t #\쁆) (else #t)))
                         (else -2))
                       0)
                      (#t (integer->char (abs #\ຄ)))
                      (#f #\㮟)
                      ((if (if #\Ꙅ #f #f) #t (char? #f)) #f)
                      (1
                       (if (cond (#t #\U0007C467) (else #t))
                           (if #f #\U0004837C #t)
                           #t))
                      (#\葇 (if #t #t #f))
                      (else #f))
                    (if #\U000E69A6 (- (if #t 6 #f)) #f))
                   ((boolean? #\U00053A26)
                    (cond
                      ((cond (else (if #\U0006DE7B #t 8))) #f)
                      (else (cond ((if #f 2 -3) -5) (else #\⍩)))))
                   (#f (char? #f))
                   (#t (zero? #f))
                   (#f #f)
                   ((cond
                      (13 #\艍)
                      (4 (integer? (char->integer #\U00042D0C)))
                      (else 6))
                    (if (cond (else 0)) #\आ #t))
                   (#f
                    (integer->char
                     (cond
                       (-2 #\얨)
                       (#\官 1)
                       (#\᱂ (boolean? #t))
                       (-2 (abs #\衺))
                       (#f (if 2 #f #f))
                       (#f #f)
                       (else (cond (#f #\U00010C9E) (else #f))))))
                   ((if (boolean? #f) #\U000AA413 #t) #t)
                   (#t #t)
                   (else #f))))
            ((let ((y0 #\䘟)) y0) #f)
            (#t #t)
            ((let ((y0 #t)) y0) #\uAAC8)
            (-1 #\U000566F1)
            (#\虚 #\袖)
            (else
             (cond
               (#\U00032777 #f)
               (#\硬 #f)
               (else
                (char? (if (if -2 #\U00053D1B #f) (sub1 2) (if #\샴 #\喂 #t)))))))
          (integer->char 3))
         (-3 #t)
         (else
          (cond
            (-1 #t)
            (0 -2)
            ((cond
               (#f #f)
               (#t
                (if (boolean? -4)
                    (if #t (integer->char #t) (char->integer (if #f -3 #\U000F4862)))
                    (- #f)))
               ((integer? #t) (sub1 4))
               (#\᮲ #t)
               (else -1))
             (cond
               (else
                (cond
                  (#\U000DB73B #\쾩)
                  (2 #t)
                  (#\U000A8C39
                   (if #f
                       (cond
                         ((if 1 #f #f) #f)
                         ((if #t 4 #t) #f)
                         (-1 (if #\㽭 #t #t))
                         (#\U000D6981 (- #f))
                         (#f -2)
                         (#f #t)
                         (#\턢 (if #t #\U000A0E3A #f))
                         (#f #t)
                         ((sub1 -4) -6)
                         ((abs #\U000D6E53) #\銧)
                         (-1 #\퐌)
                         ((if #f -2 3) #t)
                         (#\U0008F626 #t)
                         ((char? -1) #t)
                         (-3 (if #\U000CE389 -1 #t))
                         (else (if #\揊 #f 7)))
                       #f))
                  (#\U000F7BFA (char->integer #t))
                  (else
                   (if #t
                       (if (cond
                             (-2 #f)
                             (#t 4)
                             (#\U000A7FD6 #\U00072C85)
                             (#\U0007CD4F #t)
                             (else -2))
                           (add1 #f)
                           #\㎫)
                       (cond
                         ((cond
                            (#t #\眢)
                            (6 1)
                            (#f #\晈)
                            (#f #f)
                            (#f 66)
                            (#\U000CBE00 #\ቼ)
                            (#\㶧 #\͇)
                            (#\뭌 #t)
                            (#f #t)
                            (3 -4)
                            (else #t))
                          (cond
                            (#f #t)
                            (#f #\U00017839)
                            (#t -2)
                            (#f #t)
                            (#t #f)
                            (#f #\詺)
                            (#t 1)
                            (#f #t)
                            (#\გ #t)
                            (else #\ꐻ)))
                         (else -3))))))))
            (#\硣 #t)
            (#f #t)
            (#\섭 #t)
            (-3 (let ((o1 #t)) o1))
            (-1
             (cond
               (#t -1)
               (#t #t)
               (#t 2)
               (#t #\U000542AC)
               (#f #t)
               (#t
                (cond
                  (#\ⴭ #t)
                  ((add1
                    (cond
                      (#\狮 4)
                      ((cond (#f #t) (else #f)) (if #\uF5F2 #f #t))
                      (else #t)))
                   #f)
                  (#f #t)
                  ((cond
                     ((cond
                        ((if #\U000154AC #t -4) #t)
                        (#t #f)
                        ((char->integer -1)
                         (cond (#f #f) (#t #t) (#f 10) (#t -1) (else -3)))
                        ((if #f #t #\拗) #\U000D9E57)
                        (1 (if #t #f -1))
                        ((if #f #\⸳ #\U00088F6C) #\U000EC10A)
                        (#\̀ 1)
                        (#t
                         (cond
                           (4 #\U0005D01B)
                           (#f #f)
                           (#\U000F79E7 #\즈)
                           (1 1)
                           (#f 5)
                           (else -6)))
                        (#t (if #f -3 #\U00065226))
                        (#f (if #\⟐ #f #f))
                        (-1 #\U00098870)
                        (#f #\U000EE8B5)
                        ((cond (#\U000FED42 #\𡶃) (#f #t) (1 256) (else #\U00062690))
                         -2)
                        (#f
                         (cond
                           (#f 4)
                           (#t #\U000FB3E8)
                           (-16 #f)
                           (#\ნ #t)
                           (#f #f)
                           (#\U0001868F #t)
                           (#f -1)
                           (#\U00083065 #t)
                           (#\袔 #t)
                           (#t #f)
                           (#\臥 #f)
                           (#\깩 #f)
                           (#t #t)
                           (#f #\⏹)
                           (else 4)))
                        (else #\ᴵ))
                      -3)
                     (#t (integer->char #f))
                     ((if #f (add1 2) (cond (#f 1) (else #f))) #\삀)
                     (#f #f)
                     (-1 (if #\U00057A73 #f (cond (else #f))))
                     ((if (cond (#\𨍠 #f) (#t #\䄨) (#f #f) (#t #f) (else #f))
                          #f
                          (char->integer #t))
                      (cond (#\U000E15C3 #t) (else #t)))
                     ((cond (else -5)) (cond (else #f)))
                     (#f (if #f (abs #\佛) (zero? #\U00032D48)))
                     (#\妛 (sub1 #\U000B9A63))
                     ((if 128
                          (cond (-4 #t) (else #f))
                          (cond
                            (-1 #f)
                            (#f #t)
                            (#t #f)
                            (#\U0007B898 #t)
                            (#t -2)
                            (#\U0007110B 0)
                            (#f #\Ὶ)
                            (else 2)))
                      #t)
                     (else #t))
                   3)
                  (-1 #t)
                  ((if #\㘱
                       #t
                       (abs
                        (cond (#\U000F5612 #\绣) (-2 #\U0005C814) (-3 -3) (else #t))))
                   #\包)
                  (#t -3)
                  ((cond (else #\U00094A11)) #f)
                  ((if -5 #t (sub1 #f))
                   (cond
                     (else
                      (if (if #f #t #\嗤)
                          (if #\U00103149 #t -1)
                          (cond (#t -2) (else #f))))))
                  (else #\U000D391C)))
               (#f 2)
               (#t #\U000A2B0C)
               (1 #t)
               (#f (integer->char #f))
               (#f #\U000ED31C)
               (#t #t)
               (#t #f)
               (else #t)))
            ((cond
               (else
                (cond
                  (#\U0005E99B #t)
                  (#\U0010531C #f)
                  (#f
                   (abs
                    (cond
                      (-1 (cond (#\嬵 4) (#t #\uA97E) (#\ഇ #t) (else #t)))
                      ((if 0 #\U000126A1 #f) #f)
                      (#t 8)
                      (else #f))))
                  (#f #\U000F1F38)
                  (else
                   (cond
                     (33 1)
                     (5 (cond (else #\靗)))
                     (#\U0004DB4E #\ᐔ)
                     ((if (- #\Ȫ) (integer->char #\U0010273F) 1) #f)
                     (#f #t)
                     ((- #\ꖛ) #f)
                     (else #t))))))
             1)
            (#t #\U000C1F36)
            ((cond
               (#f 2)
               (#f #t)
               (else
                (cond (else (if (abs (if -1 #t #f)) (boolean? #\U00089335) #f)))))
             (cond (else #t)))
            ((sub1 2) -2)
            ((cond
               (#\쪀 #t)
               (-6 #t)
               (#f #t)
               (#f #f)
               (#f #\Ĕ)
               (#t #t)
               (#\埫
                (-
                 (integer->char
                  (if (cond
                        (#t #t)
                        (#t #\u2BFD)
                        (#\U00039D0F #\瓜)
                        (#\໌ #t)
                        (else #f))
                      #f
                      #f))))
               (else #f))
             (if #f (char? #f) #\U00056AFE))
            (#t
             (cond
               (#t 3)
               (3 #\U00066DF7)
               (#f #t)
               (#t #f)
               ((cond (else (if #\U000BABED #t (if #\様 0 #t)))) -4)
               (#\鐷 #f)
               (else
                (cond
                  ((add1
                    (char->integer
                     (cond
                       (#f -1)
                       (-1 -16)
                       (#f #t)
                       (0 #\ꃝ)
                       (#f #f)
                       (#\䐔 #t)
                       (#\U0009B349 #\U000C4E6D)
                       (-256 #t)
                       (#\u0EE9 #f)
                       (2 #t)
                       (#f -3)
                       (5 #\U00062B06)
                       (#f #f)
                       (2 -256)
                       (#f -3)
                       (else #t))))
                   #f)
                  ((cond
                     (#\𝀺
                      (cond
                        (#f 5)
                        (#f
                         (cond
                           (#t #\뛝)
                           (#t -6)
                           (#\U0010E414 #f)
                           (4 #\U000D217B)
                           (#t #f)
                           (#\U000C83E1 2)
                           (#t #\牞)
                           (#f 1)
                           (#\U0005EE1E 4)
                           (3 #t)
                           (#t #t)
                           (#\U000DF5A0 4)
                           (-16 #\察)
                           (#\ൌ #f)
                           (#f 0)
                           (#t #f)
                           (#\U000C8DF3 7)
                           (#t #f)
                           (else #\⬹)))
                        ((integer->char #f) (if #f -9 #\U0004925A))
                        (else #\U0006110D)))
                     ((boolean? (if -8 1 #f))
                      (if (cond (#\U0005C4B6 #t) (#f #\U000A8C4E) (else #\U000404E9))
                          (if #f #\U00013C72 #f)
                          (cond
                            (#t 2)
                            (1 #\𦵧)
                            (#\U000BF105 #f)
                            (#\U0010DC1A #f)
                            (#f #f)
                            (-1 #f)
                            (#\U0001C6AE #\꿀)
                            (else #t))))
                     ((if #t
                          (cond
                            (#f 9)
                            (#t #\U0002E14A)
                            (#f 3)
                            (#f #t)
                            (4 #f)
                            (else -4))
                          #\U0008B370)
                      #t)
                     (-6 #t)
                     (#f (if -3 (if -4 #f #f) (if #f 2 #t)))
                     (#f #t)
                     (2
                      (cond
                        ((if #\䋍 -1 #t) #\U0008B16C)
                        (#t (if #t #\屜 #t))
                        (else #f)))
                     (#\샑 (integer? (integer? 2)))
                     ((cond
                        ((if #t #\䒂 #t)
                         (cond (#t #f) (#\U000FB36B #t) (#\뇛 #\슓) (#t #t) (else #f)))
                        ((cond
                           (#t #f)
                           (#t 2)
                           (#\U0008E5B5 #\쭞)
                           (#f 1)
                           (#t #f)
                           (#t -6)
                           (#t #t)
                           (-1 -5)
                           (else #t))
                         #t)
                        ((cond
                           (#f 34)
                           (#t #t)
                           (#\ힴ #\U00083807)
                           (1 9)
                           (#f #\U0004BE65)
                           (else #t))
                         (if #t -5 #\ꆈ))
                        (else -1))
                      (char? #\秐))
                     (#f #f)
                     ((sub1 #\U000A336E) #f)
                     (#t #f)
                     (#\U000AD40B #\蛱)
                     (-4 -2)
                     ((integer? #\狔) (cond (#f #\𧆛) (#f #\𫎳) (else #f)))
                     (-4 0)
                     (else
                      (if (add1 #f) #\銉 (cond (#t -8) (#\U000A1E13 #f) (else #t)))))
                   #t)
                  (#\U000E6F10
                   (add1
                    (if (cond (#f #\U000A3E36) (else -2)) 1 (cond (else #\룵)))))
                  (-1 #f)
                  ((char? #t) #f)
                  (#f -2)
                  ((char? #\ៈ) #\દ)
                  ((zero? #t) (if (cond (else 4)) #t #t))
                  (#f #\U000791E2)
                  (#\瑘
                   (if (cond (else #t))
                       (cond
                         ((if #\黩 -1 -4) (if #t #\U0003D4A4 #\U0009764A))
                         ((abs #\U000B0B50) #t)
                         ((add1 #\U000984B9) #t)
                         (#\U000A53C6 17)
                         (#f #t)
                         (#f #f)
                         ((boolean? #f) (if 1 #\ⴐ #t))
                         ((abs #f) (cond (#f #t) (#\ഴ #f) (#f #t) (else #f)))
                         (#f (if #f #\U000A7285 #t))
                         (else (cond (else 4))))
                       #\멳))
                  (#\萬 -14)
                  (#t (cond (#f (cond ((add1 -1) -3) (else #t))) (else #t)))
                  ((cond
                     ((add1 -2) #\U00063519)
                     (0 #f)
                     (else (char->integer (integer->char #f))))
                   (if (cond (else (if 2 #t #f)))
                       32
                       (if (cond (#\섰 #f) (3 #f) (else #\⣇))
                           (if #t 0 #t)
                           (cond
                             (#t #f)
                             (-4 -17)
                             (2 7)
                             (-1 #\櫲)
                             (#\惺 #\U0009024B)
                             (#\嫴 #f)
                             (else #f)))))
                  (#f (abs #f))
                  (#f
                   (zero?
                    (if (cond (#t #f) (#t #t) (else #f))
                        (if #\U0005EE9B #t #t)
                        -6)))
                  (#\U0005DAB8 16)
                  ((cond
                     (-1 -1)
                     (else (- (cond (#f #\喏) (#f #\聩) (#t #f) (else #f)))))
                   (integer->char #t))
                  (-3 (if (cond (else #f)) -7 (integer->char (cond (else 8)))))
                  (else #f)))))
            (else (cond (#\띙 #f) (#f #t) (else #\U000B47DF)))))))
      (else #t))
    (cond
      ((boolean? (if -1 #\Ⅿ #t)) -32)
      (#f #\忈)
      ((abs
        (cond
          ((let ((x2 #\U0009014F)) x2) #t)
          ((cond
             ((if (cond
                    (13 (if (cond (else 35)) #t (if #t 2 1)))
                    ((cond
                       (#\U00072F4B #f)
                       (-16 (cond (2 #\Ⳡ) (else #f)))
                       (else #t))
                     (cond (else #t)))
                    ((if 2
                         (if #f #\뙑 #f)
                         (cond (#t #\U000ED662) (-1 #t) (else -3)))
                     #t)
                    (else #t))
                  (if #f #f (if #\𡃸 (cond (else #t)) (cond (else #f))))
                  #t)
              -2)
             ((if (if #\⼔ (char->integer #f) (cond (8 #\U00081175) (else #t)))
                  (-
                   (cond
                     (-2 #f)
                     (#t #t)
                     (-4 0)
                     (#t (cond (#\춚 #\䠧) (#f #\륑) (#\韽 #f) (else 8)))
                     (2 (cond (#t #t) (#t #\峇) (else #\✱)))
                     (else #f)))
                  -2)
              8)
             (else #t))
           #\吳)
          ((cond (else #\䏖)) (let ((u2 #t)) u2))
          ((cond (#f #t) (#\U000CBD12 #t) (else 2)) #f)
          ((if #t #\矛 #\䉞) #f)
          ((cond (else #\뇾)) #f)
          (#\U000365EA
           (cond
             (#t #f)
             (#t -16)
             (#\귆 #f)
             (#t (cond ((sub1 #f) #f) (#\U0006BB8A #t) (else #t)))
             (#\U0006A788 #f)
             (-17 #t)
             (2 #\⪿)
             (#\U0005C3C3 #\泾)
             (else -2)))
          ((char->integer #f) #\쇽)
          (#f #t)
          (#t
           (cond
             ((if #\몿 (integer? 1) (boolean? (sub1 (- #\滶)))) #f)
             (#f 7)
             (#t #\墨)
             (#f #\u1A9E)
             (else #\㚫)))
          (#\₂ #t)
          (else #f)))
       (if #\U00046C29 (let ((c1 -8)) #f) -1))
      (-2 (let ((e2 #\U0009A526)) #t))
      ((let ((m2 #t)) m2) #f)
      ((sub1 -3) #t)
      (#t (cond (else 2)))
      ((cond
         (1 (char? 2))
         ((cond
            ((add1 #\U001032B5) (char? (abs #\ꔦ)))
            (2 (abs #f))
            ((add1 -3) (add1 #f))
            (else #f))
          #f)
         (#f #f)
         (#f (sub1 #t))
         (#f #f)
         (4 #t)
         (#\U0005CED9
          (cond
            ((boolean? #f) #\U000CE6D8)
            ((if (cond (else #t)) #t (integer->char #t)) #f)
            ((if #\稒 #t #\舶) (char? #f))
            (else #\u086B)))
         (#f #f)
         (else -2))
       (if (integer? 3)
           (let ((o2 #\ᬔ)) (if o2 -1 #\U000546CA))
           (cond ((boolean? 4) #\㢊) (else (let ((k0 #t)) #\㈪)))))
      ((let ((c2 17)) #t) #t)
      (else #t))
    #f
    #f
    #f
    (if #\uF697
        (if 2 3 (boolean? #f))
        (cond
          ((let ((m1 #t)) (abs #\U000AD1BC)) #t)
          ((if (let ((k2 #f)) #f) -5 #f) (if #\鶰 (integer->char -4) (if 1 #f 16)))
          (#t
           (if #\촕
               (cond
                 (#f #f)
                 ((-
                   (if #t
                       #\豭
                       (cond
                         (else (cond (#t #\䨆) (#t #f) (#f #\艴) (#f #\흶) (else #\⋥))))))
                  #\U000CF86A)
                 (#f #t)
                 (#\U00098BE5 #f)
                 (else -1))
               (cond
                 (-1 0)
                 (5 #\U000CF984)
                 (-3 #t)
                 (#\U00080589 #\U0003FFEF)
                 (2 -33)
                 (#t #t)
                 (else #f))))
          (-4 (let ((b1 (cond (4 #f) (else 7)))) #\渃))
          (#\ᵱ (let ((f1 #t)) -7))
          (else #\U000C549E)))
    #\䙘
    (if (let ((s0 (integer? (boolean? -1)))) #\U00058B7C)
        #\쵄
        (let ((b1 #\蓥)) #t))
    (if #t (if #f #f #\U000173DD) 0)
    #t
    #f
    #\U00092F27
    (let ((b0 (let ((u0 -1)) #t))) #f)
    #\ᵈ
    #f
    #\U00084FD4
    (cond
      (#f (integer? #t))
      (else (cond (#\䪘 #f) (else (if (if -1 #t #\䐳) (char? #f) #f)))))
    (integer?
     (abs
      (cond
        (#\틩 #f)
        ((cond (#\U000A588F #f) (else #t)) #f)
        (else (if #f 8 #f)))))
    (if (if (if (boolean? (if 1 #f #t)) #f #\欐) #f #\罞)
        (if #t
            (if #\U00043B05 (let ((a2 #t)) #\䗆) (if #\貊 #f -2))
            (let ((j0 (zero? #\㬊))) 35))
        #t)
    (abs
     (cond
       (2
        (abs
         (cond
           (#t #\⚣)
           (#f #t)
           (#t #f)
           (#\U0004D7B6 #f)
           (#\舙 #\U000A9476)
           (4 #f)
           (#t #t)
           (#t 9)
           (2 #t)
           (#t #t)
           (#\U000672EA #f)
           (#f #f)
           (#f (abs (zero? 3)))
           (#\◴ #f)
           (else #\U00098E96))))
       (#\U00038FB5 (integer->char (let ((n0 #f)) n0)))
       (#f (if -5 -1 #f))
       ((cond
          ((if #\U000AEC65 4 #f)
           (cond
             (#f #\U00106C63)
             (-1 #t)
             (#t #t)
             (#f -1)
             (#t 0)
             ((cond
                (#t #\U000E9D37)
                (else (cond ((char->integer #t) (if #f -5 #t)) (else #t))))
              2)
             (2 #f)
             (#f #t)
             (else -3)))
          (#f (cond (else 2)))
          (else 2))
        (cond
          ((abs #f) (boolean? 8))
          ((cond (#f #t) (#t 0) (#f #t) (else -3)) #\U000D4D84)
          ((char? #f) #\벧)
          ((cond
             (#f #t)
             (#\쟧 #f)
             (4 2)
             (0 (add1 #\U0006E0CE))
             (1 #t)
             (#\U000AF218 #\𣾇)
             (#f #f)
             (else #\U00051768))
           (let ((b1 2)) b1))
          (3 #f)
          (else (if #t #t 3))))
       ((let ((g0 #\U001065A2)) #\U00089402) #f)
       ((if #t -32 5) (let ((r0 #f)) (cond (2 2) (else #f))))
       ((let ((c1 (if -2 #t #f))) (cond (5 c1) (else 0))) (sub1 (if #t #t #f)))
       (else #\U000CD990)))
    #t
    (cond
      ((cond
         (-4 (boolean? -10))
         ((let ((f0 #t))
            (cond
              (#f #t)
              (#t -1)
              (#t #\U0009ECDC)
              (f0 f0)
              (#t #f)
              (#\ઇ -1)
              (#\U000A9781 f0)
              (else f0)))
          (abs
           (cond
             (#f
              (cond
                ((if (- (if #t #t 2)) (sub1 (if #\㈻ -6 #f)) #\䰚) -2)
                ((if (char? 2) 4 (sub1 (cond (#\U000806B5 -2) (else #t))))
                 (if (if (cond (else #t)) #f (integer? #f))
                     #t
                     (char? (zero? #\U000D5B77))))
                ((char? #t) #\U000FE3E2)
                (4 -16)
                ((if (if #t 4 (if 2 9 0)) #f #t) 1)
                (else #\U00074AEE)))
             (#f (if 4 (add1 (add1 (if #t #t #f))) #f))
             (#\⾨ #t)
             (#\㪕
              (cond
                (1
                 (cond
                   ((sub1 #t) #f)
                   (#\U00103D05 #\ʵ)
                   (#t -4)
                   ((zero? 1) #\☪)
                   (#\U0004BAAC
                    (cond
                      ((cond (#\U0002D1FA #\푛) (#t #t) (#f #f) (else #t)) #f)
                      ((cond
                         (9 2)
                         (-5 1)
                         (#f #t)
                         (0 #t)
                         (#\U000A8730 #t)
                         (else #\U0002D365))
                       #f)
                      ((cond (#f #f) (#\鿇 #t) (#t #f) (else #t)) -3)
                      ((sub1 #f) #\U000EB775)
                      (#f #\州)
                      (#f (if #f #f #t))
                      (#\U000A988A (integer->char #t))
                      (#\㔘 (cond (else 1)))
                      ((cond
                         (#f #f)
                         (#f -4)
                         (#\U000891F2 #f)
                         (3 #\U000AE351)
                         (else #f))
                       #\걚)
                      ((if #\U000C91BE #t -1) -1)
                      ((cond (else #t)) (if -3 #\젨 #t))
                      (#t (cond (4 #\⏞) (#f #f) (#t #\懠) (2 -1) (else #f)))
                      (#\U0001A77E #\U00040CF7)
                      (#f #\㓿)
                      (#t (sub1 -1))
                      ((cond
                         (-2 #f)
                         (#f #f)
                         (#\U0006AD33 #\U000BB57C)
                         (#t -3)
                         (#t -1)
                         (#t #\U00082269)
                         (#\U00042C42 #t)
                         (#\ॆ 0)
                         (#\U00087F69 #t)
                         (4 #f)
                         (#t #t)
                         (else #t))
                       (zero? #t))
                      (#\U00098F3D #\U0008B30A)
                      (#\猒 3)
                      (0 (if 0 -4 #\拿))
                      ((abs #\⸄) (cond (#f #f) (1 #\∸) (#t 8) (else #f)))
                      (else (cond (#\U000D3B93 #\ꌓ) (else #f)))))
                   ((if (if 1 #\U000BD6C8 #f) #f #\躑) (abs #t))
                   ((cond (else (if -2 -4 -8))) 3)
                   (else 0)))
                (else -1)))
             (2 #f)
             ((boolean? #t) #\U000E9B9B)
             (#t (if (if #\U000D07DF (boolean? 33) #f) 3 17))
             (#t #t)
             ((add1 #\U00084FA0) #t)
             ((if (char->integer #t) (char? 65) -2) #f)
             (else 10))))
         (-1 #t)
         (#t #\U001062E7)
         (1 (if 3 #t #f))
         (else (if #\U00055CBA -2 -3)))
       #t)
      ((let ((k1 #\洓)) (cond (#f #t) (else k1))) #t)
      (#f -10)
      (#t #t)
      (#t (let ((p2 #t)) #\U000F34A4))
      (1 #t)
      ((if (let ((r1 #t)) r1)
           2
           (if (if (cond
                     (#t -3)
                     (#t #\U00058575)
                     (else (cond ((if #t #t -1) (cond (else #t))) (else #t))))
                   (zero? (integer? #\U000847DD))
                   -1)
               (if #t #f #t)
               #\U0010B531))
       (let ((a1 #f)) (integer? (if #\u0B4A #f #\U000621E6))))
      ((cond
         (#\먼 (if -1 #\㟙 #t))
         (#f #\𨹂)
         (-2 #t)
         ((cond (else -2)) #\㈘)
         ((cond
            (#\U0006A9C0 #\氘)
            (#\U000B78EE #\U00084623)
            (#\U0010BAA1 3)
            (#f (if (char? #t) 2 (integer->char #t)))
            (else (if (if #t #\U000F1A5B #t) #\閿 #t)))
          (if 4
              (cond
                ((abs #f) (if #f #f #\㥂))
                ((if -2 #t #f) (- #t))
                (-2 #\푝)
                (#t #t)
                ((if #t #f -3) -4)
                ((cond (else #\萦)) (abs #t))
                ((char? -1)
                 (cond
                   (2 #\u200F)
                   (#\U000841A7 -5)
                   (#t -3)
                   (#\U000938CC #\U000F6348)
                   (-2 #\U00078A5D)
                   (#\𠗳 6)
                   (#f #f)
                   (else #\U00076F06)))
                (132 (cond (-4 #f) (#\U00089F6E #t) (else #t)))
                (#\壼 (- 1))
                ((cond (#f #f) (#t #t) (else #\蕽)) #\蠷)
                (-4 (sub1 #t))
                ((boolean? #f) (if #f #\U0001E0C0 #t))
                ((sub1 #f) (if #t #t #f))
                (else #f))
              1))
         (else
          (if (cond
                ((if #t #t -1) #t)
                (2 (if #f #f #\矕))
                (#t #f)
                (#t #\U00109485)
                ((if #t #t #\㊤) (if #f #t #t))
                (-2 (cond (else #f)))
                (4 -7)
                (#\U00042DE1 #f)
                (#t (if -6 8 #\찎))
                (#f (cond (1 #t) (#t 1) (else #f)))
                ((if #\U000ED296 #t 0) (if 4 #\♪ -2))
                ((if #t #f #\U000C9501) 1)
                (else (cond (else #\蟻))))
              4
              #\ꃴ)))
       (let ((p1
              (let ((j0
                     (cond
                       (#t #\ડ)
                       (#f #\䏗)
                       ((integer->char -4) -5)
                       (#f #\U000B679F)
                       (5 (sub1 #t))
                       (3 #t)
                       (#f (cond (#f #t) (else (- #f))))
                       (#f #\U0006E72B)
                       (#f -2)
                       (3
                        (if (cond
                              ((if #\U0009BBB7 #t -5) (if #f #t -8))
                              ((if #\U000DCA5D #\U000A967F -2) #t)
                              ((cond
                                 (2 -1)
                                 (#t #t)
                                 (#\U0007B886 #f)
                                 (-1 -4)
                                 (#f #t)
                                 (#f #\粡)
                                 (#f #f)
                                 (#t -9)
                                 (-4 #f)
                                 (#\諽 2)
                                 (else #f))
                               #t)
                              ((cond (-8 #t) (else #t)) #f)
                              ((if #f #f -2) #t)
                              ((zero? 1) 2)
                              (#f
                               (cond
                                 (1 #t)
                                 (#f -1)
                                 (#f #f)
                                 (#t 7)
                                 (#\謡 #\何)
                                 (-1 -17)
                                 (#t #\U000765F1)
                                 (else 3)))
                              (#f -4)
                              ((cond (-1 #t) (1 #\凄) (-4 #f) (else #t))
                               (integer->char #\寲))
                              (#f (if 0 #f 1))
                              (#f -1)
                              (#\변 #f)
                              (else (if -2 -5 #\U0008828C)))
                            #t
                            #f))
                       (#f #t)
                       ((cond (else -10))
                        (cond
                          (#f #f)
                          ((if (integer? #\돫) #\U00038765 -2) (char? (- -1)))
                          ((cond
                             (#\U0010AE16 #\U00101B5D)
                             (-10
                              (cond
                                (#f #f)
                                (#\㮙 #t)
                                (#\ꓚ #f)
                                (4 #f)
                                (#t #f)
                                (1 #\們)
                                (#f -2)
                                (#f #f)
                                (#f #t)
                                (#t 8)
                                (#f #f)
                                (#f #f)
                                (#\兮 #t)
                                (#f #\U0008BD9F)
                                (-16 #\綎)
                                (else #t)))
                             (else #f))
                           (if (cond
                                 (#\鎢 4)
                                 (-5 #\錞)
                                 (#\ዶ #f)
                                 (#f #t)
                                 (2 #t)
                                 (else #t))
                               (if #f 2 #f)
                               (if #f #\U00082CD8 #f)))
                          ((boolean? (if #\鄩 2 -1)) 4)
                          ((if 3
                               (add1 0)
                               (cond
                                 (#\밁 #\u16FE)
                                 (#t #t)
                                 (3 #\隖)
                                 (#f #f)
                                 (#f #\U00105FAA)
                                 (#t 2)
                                 (#f #t)
                                 (-1 #t)
                                 (1 #t)
                                 (else #\U0002DA2A)))
                           #t)
                          (#f #t)
                          (#t #f)
                          ((sub1 (cond (-3 #\U0009C466) (else #t))) 2)
                          (#f (if (cond (0 #f) (else #t)) #f #t))
                          (#f #\U000391D7)
                          (else #\㹍)))
                       ((if #\措 (add1 (- #\U0010ECBC)) (add1 (integer->char #f)))
                        4)
                       (else -1))))
                (cond
                  (#t #\ᝰ)
                  (#f #t)
                  (#t #\U00065031)
                  (#t #t)
                  (#\𧋥 #f)
                  (#\悎 #\U0007017E)
                  (#f j0)
                  (#t #t)
                  (else j0)))))
         #\䙴))
      ((add1 (let ((y1 (abs #\⽼))) #t)) #f)
      (256
       (if #f
           #t
           (cond
             (#\拁 #\U000F6E98)
             (else
              (if #\U0002D40F
                  (if (cond
                        ((cond
                           (#\U00063B5A
                            (cond (1 -2) (-3 7) (#t #\U000F0CA8) (else #\눷)))
                           (0 #t)
                           (#t 3)
                           ((char->integer #t) #t)
                           (#\U000C74D2 2)
                           (#t #\刃)
                           ((if 2 3 #t) #f)
                           ((cond
                              (#f #t)
                              (#t #\熀)
                              (#t #f)
                              (#\㜮 #t)
                              (2 #f)
                              (#f #f)
                              (1 -4)
                              (-2 -1)
                              (else -4))
                            (if -2 -2 1))
                           (else (if #f #f #f)))
                         (- #f))
                        (#\죒 #t)
                        ((cond
                           (#\惏 #\팁)
                           ((if #f #t #\U000331D4) (if #\邩 #t #\𠤗))
                           (4 #\U000F0DAD)
                           (-4 (if #f #f 1))
                           (#t (cond (#f 1) (#f #\𦴔) (#\⟏ #t) (#\ܬ #t) (else 10)))
                           (#t #f)
                           ((if #f #f #\U00068F12) (cond (-64 #\씤) (else #f)))
                           ((if -1 #t #\U00072B0E) #t)
                           (-1 #f)
                           (else #t))
                         (cond (#f #f) (else #\楅)))
                        (#\渢
                         (if (cond (#f #\U000908CC) (#f #t) (#f 2) (else #\飭))
                             #t
                             (add1 1)))
                        ((integer->char (if -5 #t 3))
                         (cond
                           (-5 (cond (else 3)))
                           (#\U00071F3A #t)
                           (-2
                            (cond
                              (#f #\骬)
                              (#\轐 #\볺)
                              (#f #t)
                              (#f #\U000321CA)
                              (-1 #t)
                              (else #f)))
                           ((cond (#t #\濹) (#\薺 #f) (#t #f) (else #t)) #\U00017307)
                           (else (sub1 5))))
                        (else #f))
                      #\呞
                      (cond (#f #t) (else #\U0002B858)))
                  (cond (else 1)))))))
      (else (cond (else #\U0008397F))))
    (char->integer (let ((k0 #\佣)) (cond (9 (if k0 #f #t)) (k0 #f) (else k0))))
    (if (let ((n1
               (cond
                 ((integer? 4) (if 3 #\膩 #t))
                 ((let ((h0 #\碋)) #\U0003CE3A) (if #t #f #t))
                 ((cond
                    ((if (integer? #f) -2 -1) -4)
                    ((integer->char #\U00041991) #\뮟)
                    ((if #\U000FE34A (cond (#t #\癷) (else #t)) 3) #f)
                    ((cond
                       ((integer->char 1) (integer? (if -1 #\U0001AC34 #f)))
                       (0 -3)
                       (else
                        (cond
                          ((integer? #f) (boolean? -4))
                          (#\U0002FE9A (if 34 #f #t))
                          (else (cond (-8 #\曫) (else #\嬩))))))
                     #t)
                    (#\齫
                     (if (cond
                           ((if #f #f #\U000B472D) (if -2 -1 -6))
                           ((cond
                              (#\돝 #\U00019197)
                              (#\U000763B5 #\鿁)
                              (#\직 #f)
                              (else #f))
                            #t)
                           ((char->integer #t) #\㢏)
                           ((sub1 #\U0007A3F0) (boolean? #f))
                           (#t (cond (#t #\U000D617D) (else #t)))
                           ((abs #\퇚) -3)
                           (else #f))
                         (cond
                           ((cond
                              (#t #t)
                              (#t -1)
                              (0 #t)
                              (#\䤬 #f)
                              (0 1)
                              (#f #t)
                              (#f #f)
                              (-2 #f)
                              (else #f))
                            #\U000CA32B)
                           ((if 1 2 #t) (cond (-1 #t) (#t #\U000AEC73) (else 1)))
                           ((cond
                              (#t #t)
                              (#t #\U00101621)
                              (#f -1)
                              (#\샵 #f)
                              (3 6)
                              (#t #t)
                              (#f #\U000D8EE7)
                              (#\睮 #f)
                              (else -8))
                            7)
                           (else (cond (else 1))))
                         -3))
                    ((if (cond (else (integer? #t)))
                         (if (boolean? #f) 0 (cond (else #\钄)))
                         (cond (else #t)))
                     (cond
                       ((zero? #\騘) #f)
                       (#t #\U00091242)
                       ((- -32)
                        (cond
                          (0 #f)
                          (-2
                           (cond
                             (-2 #f)
                             (#f #t)
                             (#t 1)
                             (#t #f)
                             (#t #f)
                             (-5 -1)
                             (else #t)))
                          (#t #t)
                          (1
                           (cond
                             (-5 #\U000A098A)
                             (-4 #t)
                             (#\닮 #t)
                             (-5 #\ᗫ)
                             (else #\U0010FB40)))
                          (#t #t)
                          ((integer? -3) #f)
                          (#t #t)
                          ((cond
                             (#f #f)
                             (32 -1)
                             (#f #f)
                             (#f #f)
                             (33 #\㫋)
                             (#\䦵 #\揻)
                             (2 #f)
                             (else #f))
                           (cond (#t 2) (else #\쁢)))
                          (#\项 -8)
                          (#\U000E4453 -1)
                          (#\乷 #\慑)
                          (#\U000BA69E (zero? #f))
                          (0 #t)
                          ((abs 1) (cond (else #\플)))
                          (#\U00086470 (char->integer 2))
                          ((cond
                             (#f #\꿍)
                             (-2 #f)
                             (#f #t)
                             (#f #t)
                             (#f 1)
                             (3 3)
                             (#t #f)
                             (else #t))
                           #\䋝)
                          (#t #f)
                          (#\㱁 #t)
                          (#\盜 (char? 8))
                          (else 1)))
                       (else #t)))
                    (#t #t)
                    (-3 2)
                    (#\慢 #\鵾)
                    (#t -1)
                    ((if (cond
                           (#\믖
                            (cond (#\싊 #\ꬵ) (#f #\ቾ) (#t -3) (else #\U00059AEB)))
                           (else #t))
                         (abs #f)
                         #t)
                     (integer?
                      (cond
                        (#f (cond (#\늮 -5) (else #\㖇)))
                        ((if #\拁 #t #f) #f)
                        (#t #f)
                        (#f -2)
                        (#\U000480B7 #\U00047AD4)
                        (2 #t)
                        (#f #f)
                        (#f #\U000E4CA1)
                        ((if #\U000FAF78 #t #\U000DF2F1) #t)
                        ((cond (#t #t) (-8 -10) (else 0)) (if 1 #f -2))
                        ((cond (1 10) (#f #t) (8 #\䠯) (else #t))
                         (cond
                           (#\貧 1)
                           (-1 #t)
                           (#\u9FD3 1)
                           (#\U000DC57E #f)
                           (#f #f)
                           (#\𪇼 0)
                           (-1 #\꿪)
                           (#t #f)
                           (#f #t)
                           (#f #f)
                           (#f #t)
                           (#\鸈 #f)
                           (#t 3)
                           (#\U000C8C91 #f)
                           (#t #f)
                           (#\蒥 -4)
                           (-1 #t)
                           (#t #t)
                           (#\奠 #\铮)
                           (else #t)))
                        (#\U000A9B49 10)
                        (3 #\U000ABF2C)
                        ((char->integer #\냪) (- 1))
                        ((if #t 2 #\櫎) -1)
                        (#\U000A36DE #f)
                        (#f #f)
                        (#t (if #t #t #f))
                        (#t #\U0007331A)
                        (2 (add1 2))
                        (else (if 2 #f #\튆)))))
                    (else
                     (cond
                       (1 #f)
                       ((if (cond
                              (4 #\U0004995E)
                              (#t #t)
                              (#\ꊇ #f)
                              (#\ű #t)
                              (#f -2)
                              (#f #f)
                              (#t #t)
                              (else #f))
                            (if #t #t 0)
                            (sub1 #\U000D36CC))
                        #f)
                       ((cond
                          ((cond (9 #f) (else #f)) #t)
                          (#t (if #t #t -33))
                          ((if #f #t #f) #\ๆ)
                          ((cond
                             (#f #\䦁)
                             (#\U000473C1 -1)
                             (#f #f)
                             (#\ဦ -6)
                             (else #\U000A311A))
                           (cond
                             (#t 4)
                             (#f #\⇹)
                             (#f #t)
                             (3 #\핐)
                             (2 #t)
                             (#\U00052B63 #f)
                             (else 19)))
                          (#t (integer->char 6))
                          ((integer? #t) #f)
                          (-1 (boolean? #f))
                          (#t #\U0010B407)
                          (#f #t)
                          (else #t))
                        (if #\U00067725 #\U00043F6B 4))
                       ((if (cond (1 #f) (-4 #f) (else #\燼)) #t #\U000F4E7A) 1)
                       (else #f))))
                  #t)
                 (else
                  (cond
                    (2
                     (cond
                       ((if #\U001038EB #\裰 (boolean? #\絝))
                        (if 2
                            (- #t)
                            (cond (#f -3) (-8 #f) (-2 #\U000FE995) (else #f))))
                       (#t #f)
                       (else #\쯖)))
                    (#\㍠
                     (if (cond (else (cond (#t -4) (else #f))))
                         (cond
                           ((cond
                              (-4 #\U0008A15A)
                              (#\U00057DFA 0)
                              (#t #\U000CF255)
                              (2 -1)
                              (#f #t)
                              (else #f))
                            (cond
                              (#t #f)
                              (#\邼 #\큳)
                              (#f #t)
                              (4 4)
                              (#t #f)
                              (#t -10)
                              (#f #f)
                              (else #t)))
                           (-12 2)
                           ((cond (else #\U0001FDEF)) (if #f #\㧒 #f))
                           (#t #t)
                           (#t #t)
                           (#f #\U000D538A)
                           (#t #t)
                           (#t #f)
                           (#t 2)
                           (-10 #t)
                           (1 (if #\U000D3260 #t #\U0010D50D))
                           ((if 1 #\U000E83FA #t) #\U000CF158)
                           (2 (if #f #\U00042BEC #f))
                           (#\ᠸ #t)
                           (#\䰓 (cond (#\U0005B946 #t) (6 #t) (else #t)))
                           (else (cond (#\꧍ #\U000A3188) (2 #f) (#\鵼 -3) (else 1))))
                         (cond
                           ((cond (#t -2) (else #\‷)) 3)
                           (else (integer->char #t)))))
                    (else #f))))))
          (let ((c1 (cond (-4 #f) (-1 2) (#t #f) (else #t))))
            (char->integer c1)))
        (cond
          (#t #f)
          (else (if (cond (else #\U0010240D)) #\U00090337 (let ((d2 #\ꂲ)) #f))))
        (let ((l2 #\鼎)) #\謫))
    (if #\者 (if 4 #\倾 (let ((g1 0)) (let ((q2 g1)) q2))) #f)
    (let ((c2 #\琾)) (let ((f2 (let ((t2 #f)) (if t2 #\栠 #\U0008D8CA)))) #t))
    #f
    (if #t #f (if #\U000B65B6 (char? #f) #f))
    #\歱
    (if (let ((w0 #t)) #t)
        (abs
         (if -19
             (cond
               ((cond (else 2)) #t)
               ((if #\U00081A5F #\U000A6656 #t)
                (cond
                  (#t 0)
                  (#t 1)
                  (#t 10)
                  (-3 2)
                  (#t #\U0001A5D2)
                  (#t #\▖)
                  (2 #f)
                  (#f #t)
                  (else #\U0005C555)))
               (#\U000BEEAE (cond (else -9)))
               (#\U0008EB1F (if #t 2 #t))
               ((if 0 #t #f) #\牖)
               ((if #t #f #t) -2)
               (#\U000B5C28 #\U000E881D)
               (else #t))
             #f))
        (- #f))
    (cond
      ((add1 #t)
       (cond
         (#f #\㢁)
         (#t
          (cond
            (#t (if #t #f #f))
            (-3 #f)
            ((let ((u1 -66)) -16)
             (if (if #\澃
                     (if (if #t
                             #t
                             (cond
                               (#f #t)
                               (#t #t)
                               (4 32)
                               (#t #\䐀)
                               (#t #\U0007B761)
                               (else #t)))
                         #t
                         #t)
                     -1)
                 #t
                 #t))
            (else #t)))
         (#\ㇽ (char? (let ((i0 -2)) -6)))
         ((cond (else #t)) 2)
         (#f -16)
         ((if -8 #\竪 -3) #f)
         ((cond (else (if #f #t -2)))
          (cond
            ((cond
               (#\U000EE11E #\U000A5385)
               ((cond (else -1)) #f)
               (-8 #\谩)
               (#f 1)
               (else #t))
             #t)
            (#t (cond (#f #f) (#f #\𖬲) (else (if #t #\⸺ #f))))
            (else (char? #t))))
         (else #\U000FC777)))
      ((integer->char
        (if (cond
              (-4 #f)
              (1 -11)
              (#f 1)
              (#\uF877 #t)
              ((cond
                 (#f
                  (cond
                    (#\汃 (char->integer (if #f #\U00042FB2 #t)))
                    (-4 -2)
                    ((cond (else (if #\U0008C3DB -2 16))) (integer->char 2))
                    (#t (cond (#\薕 #t) (else #f)))
                    ((cond
                       ((if 4 #\U0002DE21 -4) (zero? #f))
                       (#t (if 4 #f -2))
                       (#\U000DD7F1 -2)
                       ((cond (else #t)) #f)
                       (#\𪔚 5)
                       ((cond
                          (#f #f)
                          (#t #f)
                          (#\U0007F8FF #\ᵿ)
                          (-9 2)
                          (#t -4)
                          (#t #f)
                          (#\U00096858 #f)
                          (#\U000D436C #f)
                          (else #t))
                        2)
                       (else 5))
                     -8)
                    (#t 1)
                    (#t #f)
                    ((zero? (- #t))
                     (if (cond (-1 3) (-2 6) (else -1))
                         (cond (#\韛 #t) (#f #\ೕ) (0 4) (else #f))
                         (cond (#f #f) (else #t))))
                    (else #t)))
                 (#t #f)
                 (#f #t)
                 (#t 3)
                 (8 -3)
                 ((if (char->integer (boolean? -4))
                      (if #f
                          (cond
                            (1 -2)
                            (#\U000CFB33 #\ϳ)
                            (#t #\U0008EC30)
                            (#f #t)
                            (-1 #\U000FA8A3)
                            (else 2))
                          (if #t #f #f))
                      #t)
                  -3)
                 (#\鲹 (cond (else #\U0008FC88)))
                 (else (if #t -5 (add1 (if #\⬢ #t #\U0009EC57)))))
               #\U000E594F)
              (else #f))
            (cond (else #f))
            #\U00073650))
       (if #\U000F9F9E
           (zero? #t)
           (cond
             ((cond
                (#t #\U00099664)
                (#\瘱 #\凭)
                (#t -5)
                (#t (boolean? #\簺))
                (#t #f)
                (#t #t)
                (2 #\襡)
                (#\龤 1)
                (#t #t)
                (#f #f)
                (#\U000E3851 (- #f))
                (else (- 2)))
              #t)
             ((if #\Ԯ #\u0C77 #t) #\ᗢ)
             ((integer->char #f) (if #t #t #f))
             (else (if #\U00065482 #t #t)))))
      (else #\읂))
    (cond
      ((cond
         ((cond
            ((if #t #t 0)
             (cond
               (#f #\U000E82D4)
               (#\U0003139E 1)
               (#f #f)
               (#\㘝 2)
               ((abs #\𥳳) #t)
               (4 #\䑙)
               (else #t)))
            ((cond (#f #t) ((integer? (boolean? (if #f -2 #\㧶))) #f) (else #t))
             #f)
            ((if #\U0004D9CD (if #t #f #\罈) 3)
             (cond (#\蓧 #f) (3 #f) (#\U00082DFB #f) (else 0)))
            (else (cond (else (zero? (cond (#\ꚁ (if 1 #t #f)) (else 1)))))))
          (if (if #t
                  (zero? #\琖)
                  (if (if (cond (else 2))
                          (cond (else (cond (#f #f) (#\䎨 #f) (else #f))))
                          #f)
                      #\U00055B30
                      (cond
                        (#\U0006643B (cond (else (if #f #t #f))))
                        (1 (if -1 (char->integer -4) #f))
                        ((cond
                           ((- #t) (sub1 -3))
                           ((boolean? #f) -8)
                           (#t -1)
                           ((if #f #\U00014930 2) #\靕)
                           ((if -6 #\U0002FB09 #\ൠ) #f)
                           ((if #\U0008070F #\璪 -3) (zero? #\U00053CD4))
                           (#f #\U000DBD76)
                           (-1 #\蕒)
                           (else (if -3 #f 2)))
                         #\㦩)
                        ((if 1 (if #f 1 #f) (abs #t))
                         (integer->char (cond (-5 -5) (else -2))))
                        ((cond
                           (3 -8)
                           ((cond (else #t)) (if #t #t #t))
                           ((cond (else #f)) (if #t #f -4))
                           (#f (char->integer #t))
                           ((cond (#\燧 #t) (else #\拫)) (sub1 #f))
                           (#f #t)
                           ((boolean? #t) #t)
                           ((cond (#\U000FC35D -1) (else #t)) #\젔)
                           ((zero? #t) -8)
                           (#f 2)
                           (#\易 (if #f #f #t))
                           (#t #t)
                           (else -1))
                         (abs 3))
                        ((char->integer #t) #\짲)
                        ((if (if #t #f #\U0004530D) #t (if -2 #t #\U000476F5)) #t)
                        (else #\U00015DB0))))
              -4
              -9))
         (#t 2)
         (#f
          (let ((f1 (if #t #\잰 (if #\U00011D37 (boolean? #\U000998E4) #\鄖)))) 2))
         (#\씎
          (if (cond (else #t))
              #\拪
              (cond
                (#\U0007CC24 #f)
                (#f #f)
                ((cond (#t (cond (else #t))) (#\U0006008D #t) (else 5)) #f)
                (#f
                 (if (cond
                       (-3 -4)
                       ((char? 1) 1)
                       (#\稨 (if (if -1 #t 4) (cond (-2 5) (else #t)) #\ཐ))
                       (else (integer->char (if #\𩌝 #\U0006AA3E #f))))
                     #t
                     1))
                (#\U000AD813 #t)
                (#\ଟ #\ꨆ)
                (#\U000FE01B #f)
                (#f 4)
                (#t 4)
                (else -9))))
         (#\U000C481F #f)
         (#f (let ((e0 #f)) (- #\U000CD51F)))
         ((cond ((add1 1) #t) (else #t))
          (if (cond
                (-1 #f)
                (#f #f)
                (#\u0FF3 0)
                ((cond (else -8)) 4)
                (1 #f)
                (#f #t)
                (else #t))
              (cond (#\칕 #t) (5 #t) (else 1))
              #\본))
         (#f 3)
         (else -2))
       #t)
      (#t
       (if (integer->char (if #t #\ϓ #t))
           (if (if #t #f #\U0005D27C) (if #\U0008565B #\u08CC #\U00017BAA) 4)
           (if #\ક #f #\骷)))
      ((let ((b1
              (cond
                (2 (if #f #\螓 3))
                ((let ((b1 #t)) #\U00070DA6) #f)
                (else (let ((b0 #t)) -4)))))
         b1)
       #t)
      (#f #\⽎)
      (else #f))
    (add1 #\竇)
    #f
    #t
    (let ((f1 -2))
      (sub1
       (cond
         (#t
          (cond
            (#f #f)
            (0 f1)
            (#f #f)
            (#\U0005317D f1)
            (#t #\U000506A5)
            (#f 2)
            (10 #f)
            (#\쳸 f1)
            (else #\U0010D931)))
         (#f (if f1 #f f1))
         (#\U000F7955 (zero? f1))
         (#t f1)
         ((if #f f1 f1) #t)
         ((cond
            (f1 #t)
            (#t -3)
            (#f 1)
            (f1 #f)
            (-2 #t)
            (1 #f)
            (#f 2)
            (#f #\堘)
            (f1 f1)
            (#f #t)
            (#t #f)
            (f1 #t)
            (#\U000F936F #t)
            (#f #\줃)
            (#\僕 1)
            (else 8))
          #t)
         (else
          (cond
            (#t #\࿆)
            (-3 #\飲)
            (2 #\U000EE965)
            (3 #t)
            (#t 3)
            (#t 2)
            (#f #\㜔)
            (f1 #f)
            (#t #t)
            (#f f1)
            (f1 f1)
            (else -3))))))
    #\繕
    (if #\钻
        (sub1
         (cond
           (#\仫 (cond (#t -1) (else #\ؗ)))
           (#t
            (if (abs #f)
                #f
                (cond
                  ((cond
                     (#f #\ᾕ)
                     (#f #\塠)
                     (#\U000BEFD6 (cond (else #f)))
                     ((abs #t) (cond (else -4)))
                     ((cond (else #\U0010CA05))
                      (cond (#\͜ #t) (#f #t) (#f #t) (-8 #\䠞) (#f -4) (else -7)))
                     ((if #f -1 #\败)
                      (cond (7 #\U0004D58E) (#\₃ #\U000B4C03) (else -1)))
                     (#\U0008737D (if #f -2 #t))
                     (9 #\U00081C10)
                     ((cond (#t #\U000F7397) (else 0)) (boolean? #f))
                     (4 #f)
                     (1 #f)
                     (#f #\솼)
                     (#\u1BF4 #f)
                     (else #f))
                   #\९)
                  (#f #t)
                  (#t
                   (cond
                     ((cond (#f 3) (else #\朐)) -4)
                     (0 #t)
                     ((cond
                        (#t -1)
                        (-1 #\㐢)
                        (#t #f)
                        (#f #\랛)
                        (1 2)
                        (#t #\鸢)
                        (#t 1)
                        (#\U000B6333 #\U000DD048)
                        (-12 #t)
                        (#t #f)
                        (#t #\⻍)
                        (else #f))
                      #\瘓)
                     (2 (cond (else #t)))
                     (else #\ᜂ)))
                  (#f -2)
                  (else
                   (cond
                     (#f 2)
                     ((integer->char -2)
                      (cond (#f 3) (#\U00065402 #\U000A1F53) (#f #\肠) (else -2)))
                     (#t #f)
                     (#\U0002D859 #f)
                     (1 #f)
                     (-3 #\酨)
                     ((cond (-2 #t) (#t -3) (#t #t) (else -2)) #f)
                     (-5 #t)
                     (#\uAAD6 #\估)
                     (else (if -2 #t #t)))))))
           (else -1)))
        (if #f #\uA6F9 (char? (zero? #\U000BB72D))))
    #\ᚉ
    (cond
      ((- #t) (add1 #\㝢))
      ((let ((k0
              (if (let ((a0 #f)) #t)
                  (let ((t2
                         (-
                          (cond
                            (#t (cond (else #\댁)))
                            (#t #t)
                            (-2 #t)
                            ((if #f 1 (if #t #f 2)) #f)
                            (#f (if #\䥝 #f -1))
                            (-2 #\记)
                            (#f #\U000E585D)
                            (4 #\㑕)
                            (#f #\U0008D082)
                            (-5 #\U000A4956)
                            (#t
                             (cond
                               ((if #f #\U000F3DA4 #t) #t)
                               ((if #t 5 #t) (if 13 -6 #\騺))
                               (#\ᵰ (- 8))
                               ((cond
                                  (#\U00051711 #t)
                                  (#\U000A3A8B 258)
                                  (-2 #\U00048E06)
                                  (#f -4)
                                  (#f #f)
                                  (else #f))
                                #f)
                               (#\U000802FA (boolean? #t))
                               (#\U0007E68A (cond (else 4)))
                               ((cond (#\룩 #f) (else #f)) (cond (else -1)))
                               (#t #\U000B17FB)
                               (#f #\鸁)
                               ((cond
                                  (#\U000B644C #\퉅)
                                  (3 #f)
                                  (#f -7)
                                  (#f -11)
                                  (#f #f)
                                  (-4 #f)
                                  (3 -2)
                                  (#t #\㒲)
                                  (#t #\꧞)
                                  (#f 2)
                                  (#t 1)
                                  (#t #t)
                                  (else #t))
                                #t)
                               ((sub1 #t) (zero? #t))
                               (#f
                                (cond
                                  (#\U000E4BF9 #\U00042C5D)
                                  (#t 2)
                                  (#f #f)
                                  (4 #\〘)
                                  (-8 #\亵)
                                  (#t #t)
                                  (#f -1)
                                  (#\u9FCF #t)
                                  (10 -1)
                                  (-3 8)
                                  (#t #t)
                                  (1 -5)
                                  (#f #t)
                                  (else #\U0006D834)))
                               (#t (if #f 4 -1))
                               ((if -2 #t #f) 3)
                               (else #\邟)))
                            ((if #t (if #f #\餢 #f) #f)
                             (cond ((if #t #f #\瓶) #\⢜) (else -10)))
                            (else -1)))))
                    #t)
                  (char->integer #f))))
         (let ((o1 (let ((c2 #\U0001023F)) #f))) (if #t #\巘 #f)))
       -3)
      (0 (let ((j1 #f)) j1))
      (#\U000A7FAF #t)
      ((char? #f) #f)
      ((boolean?
        (cond
          ((let ((f0 2)) #t) (cond (else #t)))
          ((let ((a0 #t)) -7)
           (cond
             (1 3)
             (0 #f)
             (#\甑 -12)
             (0 #\U0002E608)
             (#t #f)
             (-2 #\U00084408)
             (#f #\ჸ)
             ((if (if (if #f (sub1 #\𨎖) (cond (#\𣍥 #t) (#f 1) (else 1)))
                      (cond (else #\U000A5D5B))
                      #\U000FC3E3)
                  -1
                  #f)
              #t)
             (#t #\U000E9EFC)
             (2 #f)
             (#f #\첒)
             (#f 3)
             (#f #f)
             (#\㜨 #\뢮)
             (2 #\U0005BD8D)
             (else 1)))
          (else -4)))
       #f)
      (else #\U000BF7C8))
    (let ((b1 (let ((f1 #\U000FBECD)) (let ((j1 1)) (cond (else #\磈)))))) 2)
    6
    (let ((w1 (let ((w2 #t)) 4))) #t)
    0
    (if #f #f #\ፑ)
    5
    1
    #\晐
    (zero? (let ((i2 #\𨊢)) #t))
    #\U000E39ED
    -1
    (let ((f2 #\U00099982)) #t)
    (if #t #f (zero? (cond (else (zero? #t)))))
    (cond
      (#f 4)
      ((add1 #f)
       (let ((f0 (boolean? #f))) (cond ((if #t f0 #t) -4) (f0 #f) (else #t))))
      (5
       (cond
         ((if #\U0005EE64
              #f
              (cond
                (#t #t)
                (#\㋑ 3)
                (-1 #t)
                (17 #t)
                (#t
                 (cond
                   (#t #\U00085BF2)
                   (#t (if #f #t (if -7 #f -2)))
                   ((char->integer #\䵴) #f)
                   ((- #t) -1)
                   ((cond
                      (#f #f)
                      ((zero? (cond (else #f))) #\U00098C85)
                      ((cond
                         ((add1 12) (- 0))
                         ((cond (#f #\ǭ) (else #\褴)) #\㾄)
                         (#f (if 4 #\癉 #\u9FDF))
                         (#t -1)
                         ((if #t #\U000E3F57 #f) #f)
                         (#\U00064F9E #f)
                         (#\U0002BBD2 #f)
                         (else #\u181B))
                       -16)
                      ((integer? -2) -2)
                      ((cond
                         ((cond
                            (#\U000AC864 #f)
                            (#f #\U0008B7D7)
                            (#f #f)
                            (3 -5)
                            (#f #\U0005FB80)
                            (-4 #\U0004F2DB)
                            (else #f))
                          #t)
                         (else #\莕))
                       #\困)
                      ((cond (else -2)) -64)
                      (else 0))
                    #\U0010DB93)
                   (#f -3)
                   (#f #f)
                   ((if #\⇻ -17 3)
                    (cond
                      ((abs (if -3 #f 4)) #\㢼)
                      ((cond (#t (if #f #\顄 #f)) (else #f)) -2)
                      (#f (if #\U000CB93F -3 #f))
                      (#t 3)
                      (#\U0006522C (if #\U0003C9D5 (if #f #f #t) #t))
                      (else #\U00104EF8)))
                   (#\踝 (cond (#t -8) (else #f)))
                   ((if #f #t #f) #t)
                   (#\U000ACFDA #t)
                   (else #f)))
                (1 #t)
                (#t 5)
                (#t #\𣄱)
                (#f #f)
                (#\Ⳓ (cond (else (zero? (char? (add1 2))))))
                (-3 #t)
                (#f #\峕)
                (#\u244D #\U00062BD4)
                (#t #f)
                (#f #\蘪)
                (else #\U0002E94B)))
          (cond (#f (char? #f)) (else (if #\㹓 #f #\U0003211D))))
         ((cond
            ((- 2) (let ((e2 -1)) e2))
            (#\U000CED52 6)
            ((let ((z2 #\Ͳ)) z2) #f)
            (1 1)
            ((cond
               (#t #\U0008F058)
               (#\U000A7853 2)
               (#t #\U000E9009)
               (2 6)
               (#t #f)
               (#f #t)
               (#f #f)
               (5 2)
               (#\U0002BA5E #f)
               (9
                (if (if #\衍 (abs (if #f #f #f)) #\偍) #t (cond (else #\U00108CE3))))
               (#f -36)
               (#\ẃ -4)
               (-2 #t)
               (#t 1)
               (#f 6)
               (-1 #\⼅)
               (#t #t)
               (-3 #f)
               (#t -2)
               (#\U000B6079 #f)
               (else #t))
             #t)
            (else
             (cond
               (#\῁ 11)
               (#\U000684A5 #\𢦴)
               (#\U000F7B3F #f)
               (2 1)
               (3 #t)
               (#f #f)
               (else #t))))
          (if 3 (integer? #f) (let ((n0 #t)) #f)))
         (#f (cond (else (let ((x2 6)) 0))))
         (#t #t)
         ((if 0 #t (let ((v2 #t)) #t))
          (if (cond
                ((boolean? 2) #t)
                (#t
                 (cond
                   (-3 (cond ((abs #t) #f) (else (if #\䫉 #t #t))))
                   (1 3)
                   (else #\U0008AF75)))
                (else 1))
              (let ((w2 -17)) #t)
              #\才))
         (else #f)))
      ((if 4
           (integer?
            (cond (#f #\U0009B1E4) (#\鎛 2) (#f #t) (#\㻩 #t) (else #\U000F9F2A)))
           #\U00086059)
       #t)
      ((if -6 #f (zero? (if #f #f #f))) (let ((e2 -4)) #f))
      ((zero? #t) (let ((x1 #\U0002B9E5)) (let ((t0 #t)) -8)))
      (#t
       (cond
         (else
          (cond
            ((let ((g0 #\U0002CBC2)) #t) -3)
            ((if #\訒 -2 (integer->char #t)) (cond (else #t)))
            (#\U0004214A
             (if (cond
                   (else
                    (integer->char
                     (cond
                       (#f #\U0010EA62)
                       (#f 0)
                       (#t (zero? #t))
                       (#\䢀 (if #t #\U000CCE9C #t))
                       ((if 257 #t #\荽) (char->integer -2))
                       ((cond (16 #f) (#t #\U00062DCB) (#t 4) (#f #t) (else #f))
                        (char? #f))
                       (#\須 #t)
                       (-1 #\ⅉ)
                       (else #f)))))
                 #f
                 #t))
            (else
             (integer?
              (cond
                (#f (sub1 -35))
                ((if -5 #t -2)
                 (cond
                   (2 #f)
                   (#t (if (if #f 1 #t) #t 2))
                   (else (if #f (if #f #f #\Ŝ) #\U0003AF17))))
                ((sub1 (integer->char #t)) #\㕃)
                ((cond
                   ((if #\꧄ (if #\U000F02F8 #t #f) #t) 1)
                   ((cond
                      (#\U000E9470 1)
                      (#\嚙 (zero? #t))
                      (#\U00051305 4)
                      (else (cond (0 -2) (#\ᦆ #t) (else 0))))
                    #f)
                   (#t #\U000984E1)
                   (else (add1 #f)))
                 -4)
                (#\U0008204C #t)
                ((zero?
                  (cond
                    (#f (cond (#\샩 #\ⅰ) (else #f)))
                    ((if #f #t #\䆂) -1)
                    (#f #t)
                    ((if #\㫊 #\U00086F55 1) (zero? 2))
                    (#\ᖹ (cond (#t -1) (else 1)))
                    (-4 #\uA7F4)
                    ((if 2 #\U000FD1F6 0) -4)
                    ((if #t #t #\U00066FE4) #t)
                    (else #f)))
                 (cond
                   ((if -5 #f (sub1 5)) #t)
                   ((cond (else #f)) #f)
                   (0
                    (cond
                      ((if 4 -8 #\枬) #f)
                      (#f 2)
                      ((- #\鲬) (if -8 #\ꚛ #f))
                      (else (if -2 #f #f))))
                   (#\U0003C98B #t)
                   (#\蟳 #f)
                   (#\U000E649D #\U00019056)
                   (#t 32)
                   (else #t)))
                (else #f))))))))
      ((if #t (char->integer #f) (add1 (if #t #t #\뒋))) #f)
      (else #t))
    (cond
      ((if (if 4 #\U0010C741 (char->integer #\U000945FB)) -258 0) #\U0004762F)
      ((let ((j1 #f)) -2) (let ((c0 #t)) #f))
      ((let ((y2 #f)) 3) #f)
      (#\𡀬 #t)
      (else 2))
    -3
    #\U000B044F
    #f
    #f
    (add1 #f)
    #f
    -2
    (cond (else #t))
    #\珳
    (if (integer? (char? #t))
        (cond (2 #\U000A48B0) (else (if #t #\U0006F0D9 #t)))
        (cond (else #f)))
    #\U00089436
    #t
    #f
    #\곸
    -1
    (if #f
        3
        (cond
          (1 #\ힼ)
          (#t 3)
          ((if (let ((j2 #t)) j2) (integer->char #t) -2)
           (cond
             ((if #t (zero? #t) #t) (let ((m2 #f)) #\𨳾))
             ((let ((q2 #\U000AB369)) q2) #\U000B6E1A)
             ((if #f #\옶 #\餏) (char->integer #t))
             (#t #f)
             (else 133)))
          ((if #f (abs (cond (#\U00100074 #f) (else #\㠉))) #t) -1)
          (#f (if (let ((w1 -7)) #t) (cond (else #f)) (let ((x2 #t)) #f)))
          (#t #t)
          (#\U000AD5F4 #f)
          ((cond
             ((let ((r0 1)) r0) #t)
             (2 (let ((v0 (boolean? #f))) -2))
             (#f #\嵢)
             (#f #\U0009DBE7)
             ((let ((j0
                     (if (if 16 (integer->char #t) #\U000351F4)
                         (if (if (cond
                                   (#t -4)
                                   (5 #\U000A5E6E)
                                   (1 #\U00015DF2)
                                   (#t #\U00055CAD)
                                   (#f #t)
                                   (#f #t)
                                   (#f #t)
                                   (else #\ॳ))
                                 #t
                                 3)
                             #f
                             #t)
                         #t)))
                #f)
              (if -1 #t #f))
             (#\U0007E3F4 (- 6))
             ((cond (#t #\U0005C7E4) (3 #f) (-1 #f) (-2 #\㔁) (else -2))
              (zero? #\uF44B))
             (else (cond (#t #\U00067652) (2 0) (-5 #t) (else #t))))
           (if #\옐
               (cond
                 (-8 #t)
                 (#\U000E1BBA -2)
                 ((if #\㌿
                      (char->integer (if (char->integer #\U000922DB) #f #\U000127B2))
                      (cond
                        (4 #f)
                        ((cond
                           ((- #\U00058A7B) #f)
                           (#f #t)
                           (#f (cond (else #t)))
                           ((if #\빌 #f -2) #t)
                           (-1 #f)
                           (else (add1 #t)))
                         #\U0002D983)
                        ((cond
                           ((cond
                              (#\蹛 #t)
                              (#\୨ #\U0006B195)
                              (2 #\U0006B3DD)
                              (#f #\ྂ)
                              (#t #\U0003A7A9)
                              (2 #f)
                              (#\U000F15FE #t)
                              (#t -5)
                              (#t #\瑷)
                              (else #\胲))
                            (cond (#\U0006BAD0 #f) (#f 2) (else -2)))
                           (#t (boolean? #t))
                           ((cond (else -1)) #f)
                           (#\U000D01DE (integer->char #t))
                           (else #f))
                         #\턷)
                        (else (if (if #f #f #\U0002D047) #\U000E5575 #\U00063108))))
                  2)
                 ((cond
                    (-2 #f)
                    (else
                     (cond
                       (#t #\⳿)
                       ((if 4 (char? #f) (if 1 #f #t))
                        (if #t
                            (cond
                              (#\႞ #f)
                              (#\U00014FE8 -2)
                              (0 5)
                              (-3 #\U000869AF)
                              (#f #\U000D9DD6)
                              (#\㿪 -5)
                              (else #t))
                            (integer? #f)))
                       ((if #f (if #f #t #t) 2) (integer? #\ꈕ))
                       ((if 4 (zero? #f) #f) (cond (else -2)))
                       ((sub1 #f)
                        (cond
                          ((zero? #t) (zero? -10))
                          (#t (cond (#t #f) (else #f)))
                          (#\ဏ (integer->char #\ﮆ))
                          (1 (if #t #\U0005C909 #\U00078CC9))
                          (3 #f)
                          (#f (if #\♘ #f #t))
                          (#t #f)
                          ((if 1 #f 2) (cond (3 16) (#f #f) (#f #\᱾) (else #f)))
                          ((cond
                             (3 #t)
                             (#\U00072F73 #\u2D74)
                             (#f #t)
                             (#\U0009791B #f)
                             (#\咜 #\緃)
                             (else #t))
                           2)
                          (else (char->integer #t))))
                       (#\U0001E14A
                        (cond
                          (6 #\U000A772D)
                          (2 #t)
                          (#t #\U000483E5)
                          (#\몬 (cond (else #f)))
                          (-1 (if #\㱿 #f #f))
                          (#t #t)
                          (else 2)))
                       ((cond
                          (#\U000CC7FF (if #\U000CC489 #t #\U000AA5FB))
                          (#\U000F4CC4 -4)
                          (else (if #f 0 #\U0007B007)))
                        #t)
                       (#t #f)
                       ((integer->char (if #\쟔 -2 #f))
                        (cond
                          ((- -9) #\U00070722)
                          ((cond (#\㭹 #t) (else #t)) (if #f -1 #\讓))
                          (#f #\ਁ)
                          (else
                           (cond
                             (#\U0009562B #\U0009BCA5)
                             (#f #f)
                             (-11 #f)
                             (#f #t)
                             (#f #\U00046BA1)
                             (else #\敫)))))
                       (#t 1)
                       (-5 (if 5 (if #f #t #\U000B356E) (integer->char 0)))
                       (3 #\㬺)
                       (#f
                        (abs (cond (#f #f) (#t 3) (-5 #\U000B2C68) (19 #\꽀) (else 2))))
                       (#f #\⏳)
                       (else #\䅳))))
                  259)
                 (#\厫 -4)
                 (else 2))
               (if (cond (else (abs #f))) #t #f)))
          (#f (zero? #\亲))
          ((if #\뤺 1 8) (add1 0))
          ((zero? (if #f -6 0)) #t)
          (else #f)))
    (if #t #\ꈲ (let ((k2 #t)) (integer? (if -4 #t #f))))
    (cond
      ((cond
         ((cond
            ((char->integer
              (cond
                (#t 1)
                (#t #f)
                ((boolean? #t) #f)
                ((if 0 (sub1 #f) #f) #\됮)
                (#\U0006A8F1 #t)
                (1 (char->integer (integer->char #f)))
                ((if (add1 #f) #t #\紸) #\U000DAAAA)
                (else #t)))
             -2)
            (#\U000C7CF1 (if #t #t #\U00081078))
            (#\淛 #f)
            ((if #f
                 1
                 (if (if (cond
                           (1 #\튪)
                           (#f
                            (cond
                              (#f 4)
                              (#\uEBE0 #f)
                              (#\𣹽 2)
                              (#f 6)
                              (#t #\U000EC81F)
                              (#f 1)
                              (5 2)
                              (-4 #\U000CDDA4)
                              (#t -10)
                              (#f #f)
                              (2 -4)
                              (#f #f)
                              (4 #\䱢)
                              (#\U0007BAB7 2)
                              (#t 1)
                              (#f 0)
                              (#t #t)
                              (#t #\졂)
                              (#f -4)
                              (else #\U00072D82)))
                           ((cond (#f #t) (else #f)) #\졗)
                           (else #f))
                         (if (if #\륍 3 -2) (if #f #\U000C1EF1 #f) #\U000FE4C2)
                         (if (cond (#t #\絿) (0 #\U000C7D3C) (else #f))
                             3
                             (if #\U000B1431 -2 #f)))
                     #f
                     #\뻝))
             (let ((k1 #\U000F0688)) k1))
            ((- 2) #t)
            (-2 #t)
            (#t (integer? #f))
            (else (let ((c0 #t)) #t)))
          (let ((i1 (let ((h1 #\㐳)) #t))) (integer? #t)))
         (else -1))
       (cond
         ((if #\㥺 #t (integer->char #f)) #f)
         (#t
          (cond
            (#f #f)
            (#\摀 (cond (#\㭢 #\U000FB3E4) (#f #f) (#f 3) (else #f)))
            (#f (char->integer #f))
            (#t -2)
            (#t -1)
            (-2 (let ((x2 #\U00018CED)) x2))
            (else (if #f -1 #\U000D092C))))
         ((cond (else (if #f #\ꏌ #f))) #\뾼)
         (#t #f)
         ((let ((d0 (if #\駞 #t #f))) (if #t -1 d0)) (boolean? #f))
         (else (char->integer (abs -5)))))
      ((cond
         ((let ((f0 #f)) #\ݤ) #t)
         ((integer? -4) #t)
         (#\U000C8C0D #t)
         ((boolean? #\楇) -2)
         (#\U00091C0A #\䘈)
         (else
          (let ((d2
                 (cond
                   (5 2)
                   (2
                    (cond
                      ((if #t (cond (else (sub1 #t))) #t) #\둒)
                      (else #\U000BA29E)))
                   (#f 1)
                   ((- (if (char? (cond (else -3))) 3 (if 16 #f (abs -8))))
                    #\U000685CA)
                   (#\㫚 #f)
                   (#t #\瞱)
                   (#f -2)
                   (#f -2)
                   (#\U000437D0 -2)
                   ((boolean? 1) #t)
                   (else #f))))
            #f)))
       (zero? #t))
      ((let ((s0 #t)) 1) (if -1 (abs #\汥) #f))
      (#f (if #f (cond (else (char->integer -1))) #\ꉁ))
      ((if (if #\U000C93B0 (boolean? #f) #t)
           (cond
             ((boolean? (zero? #t)) -1)
             (#\썙 (let ((q1 #t)) #f))
             (else (if 1 #\U00106FD4 #f)))
           (let ((d2 #\U0010E80F)) (if -2 #t 7)))
       -2)
      ((let ((l1
              (cond
                (-1 #f)
                (3 8)
                (#f #f)
                (#t #t)
                ((if (if #\뿷 #\Ḧ (cond (else #\u13F7)))
                     -2
                     (if #t #t (if #\U0006A91C #\ຶ 3)))
                 #\U000E47F2)
                (#t #\ጜ)
                (#t
                 (if (char->integer #f) (if (if 1 #t -4) (if #f #f 2) #f) #\㤿))
                (else (char->integer #\U000D774F)))))
         (cond (else (let ((r0 #t)) #\ͭ))))
       4)
      (3 #t)
      (#t
       (if #t
           (cond
             (#f
              (cond
                ((cond (#t #t) (else #t)) (add1 #f))
                (#t 8)
                (#t
                 (cond
                   ((cond (16 #f) (else #t)) (add1 #t))
                   (#f #\Ǭ)
                   ((cond (2 #t) (#t #f) (else #\U00056C1A)) #f)
                   ((boolean? #t) #f)
                   (#t (char? #t))
                   (else (if #f 3 3))))
                ((if (if -1 #t 2) -1 #t)
                 (if (cond (#f #f) (else 5)) (abs #f) (cond (#t -1) (else #f))))
                (else #t)))
             (#\짃 #\U0008B862)
             ((cond (#t #\U00073BAC) (else -2))
              (if -2
                  (cond
                    (-2 (if #\縝 #\쐕 0))
                    ((if 1 -18 #\U00082DC4) #\U00035386)
                    ((cond (else #\U0004E683)) #f)
                    ((if #f 2 #f) (if #t #t #f))
                    ((boolean? #\䠄) #t)
                    ((cond (else #\눀))
                     (cond (#t #t) (#f #t) (#t #t) (#t 1) (else #f)))
                    (#\讚 (char->integer #f))
                    ((cond (#\㼚 1) (#f 1) (else #t)) (if #f 3 #\U000DEA19))
                    (5 #f)
                    (#f (if #t 2 -8))
                    ((char? -3) #f)
                    (#t (char? #f))
                    (else #f))
                  #t))
             (#t -2)
             ((integer->char (if #t (if #\U00064EC7 #t #t) (integer? #f))) -1)
             (#\䁸 #t)
             ((cond
                (#t (- #\𪟴))
                (#f 4)
                (#\䝄
                 (if (if -1 #f -12)
                     (cond
                       (#t #\ꦡ)
                       (#f #f)
                       (#t #f)
                       (#f #t)
                       (#\餓 #\㦛)
                       (#\U000C34DE #f)
                       (else #t))
                     (cond
                       (#\U0006380A #\ꦆ)
                       (#f 8)
                       (#f #f)
                       (#t #t)
                       (-1 #t)
                       (4 3)
                       (else #\Ѫ))))
                (#f -258)
                (else #t))
              (integer->char #f))
             ((if #f (cond (-2 #f) (-1 #f) (#t #f) (#f #\U000F1E62) (else 2)) #f)
              #t)
             ((if #f (integer->char #f) #t) #f)
             (#t (sub1 #t))
             (else (zero? 16)))
           (let ((w0 (cond (2 #t) (else #\🎠)))) (let ((v2 w0)) w0))))
      ((if #f -2 8) (let ((l0 (char->integer #t))) #\U000AC24B))
      ((char? #\്) (if (if #f #\U000B9189 (if -2 #f 1)) #f (let ((p2 #t)) p2)))
      ((let ((a0 -7))
         (cond
           ((let ((g1 0)) #t) a0)
           (-2 #\춄)
           (a0 (let ((c2 #\廤)) c2))
           (#t (if #t #t #\U00108DF8))
           (0 2)
           (#f #f)
           (#\U00037814 (char->integer #\U00102D1A))
           (#\㞩
            (cond (#t #t) (a0 #f) (a0 #t) (a0 #\U000D3EAB) (#t a0) (else a0)))
           ((if #\䍬 #t a0) (if #t #f 1))
           (a0 (sub1 #t))
           ((integer->char 16) #f)
           (2 #t)
           ((if #f #t #\U0009B605) #f)
           ((- #\ꈢ) #\嚖)
           (#\U00072E1A (cond (else a0)))
           ((let ((k2 a0)) #t) (if #f #t -2))
           ((if a0 #t a0) (if #t -2 #\𫙘))
           (#f #t)
           (#\U000F5562 #f)
           (else (cond (#t a0) (else #\U0007C3E8)))))
       #\U00035566)
      (#f (if #t 1 #\U00073522))
      ((abs #\U0010BA66) #f)
      (else
       (if (let ((s0 (let ((c1 -3)) c1))) (cond (else #\U00105AF6)))
           (add1 #f)
           #t)))
    (cond (else 3))
    #\U000307AC
    (char->integer #f)
    #f
    (let ((p1 #t)) (add1 (let ((u1 #t)) #t)))
    #f
    (cond
      ((if #t
           (cond
             ((if #\X #\U0003DA42 #t) (let ((x2 #f)) #\U0004763A))
             (2 (if #t #t 2))
             (#\U00034561 #\U00068934)
             ((if #t #f #\냜) 1)
             (#t #t)
             (7 #t)
             ((- 2) (let ((q1 (if #t #f (char? #t)))) -4))
             (#t (sub1 #t))
             ((sub1 #\伦) (if (if #f #t (boolean? #t)) -1 #f))
             ((cond
                (-2 -4)
                (#t #t)
                (#\㢺 #t)
                (-2 #\U000716D2)
                (#\U00076765 #\U000BD515)
                (else #f))
              #\U0007937F)
             (#t #t)
             ((if -9 -1 #\U000AF012) #t)
             ((let ((p0 #\鈞)) #t) (if (abs (boolean? #f)) #f #\U000539B0))
             ((if #\U000B0ED1
                  #\U000839C2
                  (if (abs
                       (cond
                         (#\U000EDF26 5)
                         (#f #t)
                         ((if #t 1 #f) (cond (else #f)))
                         (5 (if -2 #\⾘ #\U00108BB5))
                         ((integer->char 1) #t)
                         ((cond
                            (#\飖 #t)
                            (#f 2)
                            (#f #\ι)
                            (#t #f)
                            (#\斧 #\ཐ)
                            (#f #\㞞)
                            (#\쁖 -4)
                            (#\U0002C0FB #t)
                            (#t #t)
                            (else #t))
                          #t)
                         ((cond (#f #t) (#t #t) (else #\檜)) #\U00037D6B)
                         (#\矽 (cond (else #f)))
                         ((if #t #t #t) 0)
                         (#f #f)
                         (6 (boolean? 64))
                         (else
                          (cond
                            (#\飗 #f)
                            (#t 1)
                            (#t -5)
                            (#f 3)
                            (3 #f)
                            (#t #\𦳫)
                            (#f -1)
                            (-7 #f)
                            (#f #f)
                            (else #f)))))
                      2
                      #\U000FD596))
              (integer? (cond (#f #t) (#\䜧 #f) (else #\U000DEB50))))
             ((let ((i1 #f)) i1) (if #\淪 #f #f))
             (else (integer? #t)))
           (let ((e2 (if -3 2 #\U000B91C1))) 2))
       #\ĝ)
      ((if (cond
             ((cond
                ((cond
                   (#\U000D35FA #f)
                   (#f -1)
                   (#t #\U000D98CB)
                   (#f #f)
                   (#\ꢻ #f)
                   (#\䂵 -1)
                   (#t #\U0004DAFC)
                   (else #f))
                 (sub1 -2))
                (else #\閻))
              1)
             (#\U000A29AB #f)
             (else #f))
           (- (cond (else #t)))
           #\庼)
       (integer->char (let ((l1 #f)) #t)))
      (#t
       (cond
         ((cond
            (#\U000E76D2
             (zero?
              (cond
                (#\黛 (if 4 #f (add1 -14)))
                (#\㘜 2)
                (#f -2)
                ((cond (else #f)) #f)
                (#f #f)
                ((cond
                   (#\U00033191 #f)
                   ((if #f #\U000B237D #t) #\U00102B97)
                   (else (integer? #t)))
                 (- (cond (#\⡚ #\幙) (#\⟘ #f) (#t #\⇳) (#\䪈 -1) (else #t))))
                (#f #t)
                ((char->integer (if #\𩴑 #t #\U00044933)) #\U000454DA)
                (-5
                 (if (char->integer #t)
                     #t
                     (cond
                       (#t #f)
                       (-4 #\U000B1A4A)
                       (#f #f)
                       (#\⋬ #f)
                       (#t #f)
                       (else -3))))
                (#t #t)
                (else #t))))
            ((if -1 #t 2) #t)
            (else #\뺑))
          16)
         ((if -1 (integer? #f) -1) (let ((h0 #f)) (let ((a2 h0)) a2)))
         (#f (if #\U000F9D14 #f #t))
         (-2 #t)
         (9 (abs (if #t #f -6)))
         (9 (if (if 3 #\U000C85EE #f) #t 1))
         (else
          (-
           (cond
             (#f #t)
             (#f 1)
             (-5 #f)
             (#f #f)
             (0 #t)
             (#\U000870B4 -32)
             ((cond
                (#\U000F4A87 (integer? (sub1 -2)))
                ((cond (else #\삞)) #\U0008F929)
                ((if (cond
                       (#f #t)
                       ((cond (else #t)) (if #t #f #f))
                       ((cond (#f #\ే) (else #t)) (integer->char #f))
                       ((if 4 #t #t) #t)
                       ((abs #\ᖍ) (if -4 #f #f))
                       (else #f))
                     (char->integer #t)
                     (if #f
                         (cond (#\䪅 #\U00081526) (#t #t) (2 #f) (129 #f) (else #t))
                         (if #\U000CE982 #t #t)))
                 #t)
                (else
                 (cond
                   ((sub1 (if #\U0002DCB6 -6 #f)) #\뿌)
                   (else
                    (if (cond
                          (#\U00043177 #\U0005C6F8)
                          (#\U0004BA9D #t)
                          (else #\U00066E32))
                        (cond (#f #\꺈) (#\U0003605F #\U00105DF8) (#t #t) (else #f))
                        (cond
                          (#t #f)
                          (#f 3)
                          (#t #t)
                          (#\섏 #\嶀)
                          (#t 2)
                          (#\U000EEC50 5)
                          (#t #f)
                          (#f -2)
                          (#t #t)
                          (#t #\꾵)
                          (#f #\輰)
                          (#t #f)
                          (#\U000CF4CA -1)
                          (#f #\U00076736)
                          (#t 0)
                          (#t #f)
                          (#f #\U00014786)
                          (else 4)))))))
              #f)
             (#f #\㱂)
             (else 0))))))
      ((let ((i2 #f)) #t)
       (integer->char
        (sub1
         (sub1
          (cond
            (-1 #\䁂)
            ((if (add1 3) #\U000684FF #t)
             (cond (#f (zero? #t)) (#t #t) (else #f)))
            (else #t))))))
      ((let ((y0 #t)) #f)
       (char->integer
        (cond
          (#\U000CED86 #t)
          (#t (cond (#t #t) (#f #f) (#f -4) (-8 -8) (else 3)))
          (else (- #t)))))
      ((if (cond
             (#\U00013CE2 (cond (#f 5) (else 2)))
             ((if 2 -6 #f) (if -1 #\ꡨ #t))
             ((char->integer #f) (cond (#t -3) (else #f)))
             ((integer->char
               (cond
                 ((sub1 #t) (if #f (abs #t) (add1 (if 1 #\U00040CD0 #f))))
                 ((if #\U000C46F0 -9 #\U000AA81C)
                  (cond
                    (-2 #\皫)
                    (-2 #t)
                    (#t #\袳)
                    ((if (cond
                           (-2 #\ң)
                           (#t #\U000ED73E)
                           (-33 #\U000CE581)
                           (2 #t)
                           (#f #f)
                           (#f #\욮)
                           (#f #\㚳)
                           (#f 1)
                           (#\풻 -3)
                           (-2 #\U0004C0A2)
                           (#\ꉙ #t)
                           (#t -8)
                           (else #f))
                         2
                         #f)
                     (cond
                       (#\陚 (cond (else #t)))
                       (#t (zero? #\U000FD796))
                       (#f (boolean? #t))
                       (#t #t)
                       (else -1)))
                    (#f 8)
                    (#\ṽ -5)
                    ((sub1 (if #f 2 #f)) #f)
                    (#f #\蓾)
                    (else -3)))
                 (#\U000B9193 #f)
                 ((zero? 1)
                  (cond
                    (#t #f)
                    (#t #\嗨)
                    ((if -1 (if #t #f #f) (zero? -1)) #t)
                    (#t
                     (cond
                       (#\U0002D645 (cond (#f #\噖) (#f #\U000C1F8D) (else #t)))
                       ((if #t #f -8) #t)
                       ((if #t #t #\竀) (char? #f))
                       (else -2)))
                    (#t (char? 2))
                    ((cond
                       (#\ⷩ (abs #t))
                       (#\췚 (cond (#t -5) (#t 2) (else #f)))
                       (#f #\䜆)
                       ((if #f #\賋 #t) #f)
                       (#t #f)
                       (3 8)
                       (#f (zero? -2))
                       ((if #\懤 7 #t) (if #t #\u139D #t))
                       (#f #t)
                       (#\U000AF71C
                        (cond (5 #\U00016E7D) (-5 #\傓) (2 #\枉) (-65 -3) (else #f)))
                       ((if -11 4 #\퐺) #\U0004B7C8)
                       (#t #\Ҹ)
                       (#f #f)
                       (else -18))
                     #\繄)
                    (else -2)))
                 ((- (add1 #t))
                  (if (- #\䝗) 2 (if (if #t #f #t) (if -1 2 #f) -17)))
                 ((char?
                   (cond
                     ((cond
                        (#f 1)
                        (-3 #f)
                        (#f #t)
                        (#t #\U00098EC0)
                        (#\努 #f)
                        (else #f))
                      #t)
                     (#\U0009B51E #\둶)
                     ((if #t 2 #t)
                      (cond
                        (#f #f)
                        (#\U00041C28 #f)
                        (#\策 #t)
                        (#\U00044D21 3)
                        (#\U0008FBA9 #t)
                        (#\錂 #f)
                        (else #\컓)))
                     (#t (if #f 2 #t))
                     ((cond (#\U0003CF49 #\𨯽) (#\刌 2) (else #\U0003BDBE)) 5)
                     (-1 #\괃)
                     (#\U0006BC3A #f)
                     (else (cond (else #t)))))
                  (cond (else (if #f #f -2))))
                 ((cond (else #t)) -2)
                 (#f #f)
                 (#t
                  (cond
                    (3 (if (if #\U00056C84 #\U00046F89 4) (if 1 #\呩 #t) (sub1 #f)))
                    ((integer->char -4) (cond (else (zero? #t))))
                    ((cond (else (- 32))) 1)
                    ((cond
                       ((integer->char #\U000F2F33) #\㳓)
                       ((cond
                          (#t #t)
                          (#f -4)
                          (#t 3)
                          (#f -6)
                          (#\欠 #t)
                          (#\剥 #f)
                          (else #f))
                        (cond (#f #\鴵) (else #\U000CD588)))
                       (#f -1)
                       ((char? #t) #f)
                       ((if #f 8 #\㒵) (zero? #\U000319D1))
                       ((cond (4 #t) (#f -1) (#t #\졎) (else #\U000BFF77)) 1)
                       (#\跍 -5)
                       (else (cond (#\䏻 -2) (#t -16) (else #f))))
                     #f)
                    ((if -2 (boolean? #f) #t) #\ꠀ)
                    (-4 1)
                    ((integer->char
                      (cond
                        (#\U00057037 #t)
                        (#t #f)
                        (#t #f)
                        (#t #f)
                        (#t #f)
                        (else #\揟)))
                     (integer? (char->integer #t)))
                    ((if (integer? #\蛿) (cond (else #f)) #\툘) #\U001035F5)
                    ((cond (3 #f) (else 3)) -1)
                    ((char->integer #f) -7)
                    ((if (cond
                           (#\U000E39FD #t)
                           (#t 0)
                           (#t #f)
                           (#f #f)
                           (#\U000F92CE -1)
                           (#\求 #\蓖)
                           (else #\U00105838))
                         #f
                         #\U00068CAE)
                     #f)
                    (#\𦫟 (cond (else #t)))
                    ((if (if #f #t 2) (if #\၌ #\㮬 #f) (if #t #t #\婁)) (add1 -1))
                    (else (if (cond (#\᳇ 2) (else #t)) #t 1))))
                 ((cond
                    (#t -2)
                    (#\U000F27CC (char->integer (integer? #f)))
                    ((char->integer (if #t #f #f)) (integer->char #f))
                    (else
                     (cond
                       ((cond (#t #f) (1 -3) (else -2)) (if #\U0003B5D0 -3 #f))
                       ((cond (#t #t) (#t 1) (#\U000190FB #f) (else #\輰)) 8)
                       ((cond
                          (#f #f)
                          (#\⽧ #f)
                          (#t #f)
                          (#\삤 #f)
                          (#f #\Й)
                          (9 #f)
                          (#\曚 #t)
                          (-11 #\卓)
                          (-3 -4)
                          (#\U00040222 #\ീ)
                          (#\ᑡ #t)
                          (#t #\U00038B31)
                          (#t #t)
                          (#f #\U000AB7A6)
                          (#\U000E8A38 #f)
                          (#t -2)
                          (#t #f)
                          (#t #t)
                          (#f #t)
                          (else #\킓))
                        #f)
                       ((if #t #t 4) #\U0004DD71)
                       ((if #t 4 -1) #f)
                       (#\ꘃ (integer? #f))
                       (#t #f)
                       (#\禴 2)
                       ((if 4 #f #t) 9)
                       ((cond (#t #\즍) (else 4)) (if #\랈 9 #t))
                       (#f (cond (#\鈨 -2) (#t #f) (#f #f) (else #t)))
                       (#f -2)
                       (#\U000D9E63 (char->integer #\㊲))
                       ((cond (#t #f) (#f 4) (#t -9) (11 #f) (#f #f) (else -1))
                        (integer->char #t))
                       (#t (if #\u0A7C #\U00043E24 #f))
                       (4 #f)
                       (#f (zero? #f))
                       ((abs 5) #\溜)
                       ((if #\U00092817 1 #f) #f)
                       ((char->integer #\쭿) #f)
                       ((cond
                          (#\U00043C8E #t)
                          (#\U0008C779 #\ਵ)
                          (#t -1)
                          (#\႗ #t)
                          (-6 -4)
                          (#f #\촅)
                          (-5 #\픑)
                          (#f #t)
                          (else #\玜))
                        (char->integer 1))
                       (else
                        (cond
                          (2 #t)
                          (-2 #t)
                          (#f #\U00087865)
                          (-3 #\U0009B793)
                          (#f #t)
                          (#t 2)
                          (#t #f)
                          (-1 #t)
                          (else #f))))))
                  -16)
                 ((if (if #f (if #t #t #f) #t) #\U000BB5A2 #t) #\U000F6EE1)
                 (#f (char? (if (cond (else 3)) #t -256)))
                 (#t (integer->char #t))
                 ((integer? #\U0010CFA6) -1)
                 ((if (cond
                        (#t (cond (#\U000A714E #f) (-2 #f) (8 #t) (else #\娺)))
                        (#\逡 #\넕)
                        (else #t))
                      #t
                      #\U00036741)
                  (if #f (if (cond (else #t)) (sub1 1) #t) #t))
                 ((cond
                    (#t #t)
                    (#\├ -1)
                    ((boolean? #f) (if 2 4 (if #\焰 #\U00044B1F #\U0010234E)))
                    ((sub1 0) #\𥏣)
                    (else (if #t (cond (1 #\霶) (else #t)) -1)))
                  #t)
                 (#f (add1 -4))
                 (#\U000D59E3 (if #t #\U00065AF7 -3))
                 ((boolean? (abs #\U000FAAB1)) #f)
                 (-3 #t)
                 (#t (if (add1 #t) (integer->char (char->integer 4)) #t))
                 (#t #\𝇃)
                 (else (cond (else #f)))))
              #t)
             ((integer->char #t) #f)
             (#f (cond (else #f)))
             ((cond (#f 1) (else #t)) 1)
             (#f #f)
             (2
              (if #f
                  (cond
                    ((cond
                       ((add1 (cond (-32 #f) (else #f))) #f)
                       (#f
                        (if #f
                            (if #f #\U000EA291 #f)
                            (cond
                              (#t 32)
                              (#\혗 #\氶)
                              (-9 #f)
                              (#t -7)
                              (#\룕 8)
                              (4 4)
                              (else #f))))
                       (else (if (if #\餹 -1 2) (integer->char #f) (zero? 1))))
                     3)
                    ((cond
                       (-6 #t)
                       (6 #\퉗)
                       (#\𧩸 #\⸱)
                       ((cond (#f #f) (else -2)) #f)
                       ((cond (else #\왠)) (integer->char (if #f #\兜 2)))
                       (#\U00103820 #\U0003B030)
                       (else #t))
                     #t)
                    (else #t))
                  #f))
             (2 2)
             (#f (zero? #\U0009A1A8))
             ((char->integer #f) -2)
             (-1 (cond (#t -2) (else -2)))
             (#\U0008D299 #\杰)
             (#f #t)
             (else (if 1 5 #\U000B8478)))
           (if (let ((y2 #\U001012CB)) 1) #\™ (let ((w0 6)) #f))
           #t)
       (let ((v2 2)) #\u2BF1))
      (-4 (integer->char #t))
      ((cond
         (#f
          (cond
            (#t #\듎)
            ((let ((b0 2)) 0) (char->integer 1))
            (#\⧐ (- #\稥))
            (else (cond (else #t)))))
         (else
          (let ((a1
                 (if #f
                     #\ᰙ
                     (cond
                       (#t 17)
                       ((zero? (char->integer (cond (else -4)))) (integer->char #t))
                       ((cond
                          (#t #t)
                          (#f #\U000460D7)
                          (#\U0006F1FE (char->integer (sub1 #\雯)))
                          ((cond
                             (#t #f)
                             ((cond
                                (#t #\U000F7148)
                                (#\U000D4655 #f)
                                (-7 #\U000C5F09)
                                (#\𦤔 -10)
                                (#f #\䉳)
                                (3 #t)
                                (#\U000FB1CC #f)
                                (-10 #t)
                                (#\U000E918A 2)
                                (else #t))
                              #f)
                             (#t (cond (#f #\굜) (#f #t) (#t #t) (else -1)))
                             (#\u0E89 (cond (-5 #t) (else #\쓒)))
                             (#\U000E7873 (cond (0 -2) (else -1)))
                             (#\U000BF1EC (abs #t))
                             (#f -2)
                             (else (if #\U000F67B4 1 #f)))
                           #t)
                          (#f (if #t #t -10))
                          (#\ⳛ #t)
                          ((if #f (integer->char #\𐙈) (if #\풆 #t -7))
                           (cond
                             (#f (char->integer #f))
                             (#\⥤ #\U00098CDB)
                             ((cond
                                (#f #\U000F1B7E)
                                (#\ἢ #\墔)
                                (#f #\U000C1776)
                                (#f #f)
                                (#t #f)
                                (else 1))
                              (abs #\U00013DA7))
                             (#\U000995CE #f)
                             ((cond (-3 #f) (#t -3) (else #f)) #f)
                             (#t #\䅳)
                             (#t -3)
                             (#\u0864 #f)
                             (1 #t)
                             (#f (if #f 1 -2))
                             ((if -5 #t #f) (- 8))
                             (else (char->integer #t))))
                          (#t (if (if #t #t #f) #\란 (if #\𧀭 #t 3)))
                          ((char? #f)
                           (if #\U00098150 (cond (#t #f) (else -1)) (- #\U0007B9DF)))
                          (else (char? #f)))
                        (cond (else #t)))
                       (else
                        (if (if (cond
                                  (#t #\U0001C8B6)
                                  (#f #\U00048750)
                                  (#f #\詡)
                                  (else #t))
                                (if #\콰 #f -5)
                                (char? -1))
                            #t
                            #\垓))))))
            (if a1 -8 #f))))
       #\U0007C016)
      (#t #\U000FC404)
      (else #\U000AFBA6))
    (add1 #f)
    (cond
      (-15 2)
      (3
       (char?
        (if #\U000AC6EA
            (cond
              (1 (if #f #\U000D6FE7 #\饱))
              ((-
                (cond
                  (#f (cond (#\U0010E7BA 2) (else (if #t #t #t))))
                  ((cond (else (if #t #t -513))) #\࣪)
                  (#\됈 #t)
                  (#\簍 1)
                  (else (if -1 #t (integer? -1)))))
               #t)
              (else -5))
            -1)))
      (#f #\U00061F54)
      (else (let ((a0 1)) #\U0008C35D)))
    #f
    (cond
      ((if #\U000698E2
           (let ((m1 (let ((o0 #t)) #t))) (zero? 1))
           (if 4
               #\宒
               (cond (#t 2) (#\晷 #t) (#t 1) (#f #t) (#\U000C1C93 #\뢐) (else #f))))
       #t)
      (else #\U000E5CB3))
    (let ((v1
           (cond
             ((cond (else (cond (else #t)))) (add1 #\U000455AF))
             (else (if #t #t (cond (else #t)))))))
      #f)
    3
    #f
    #t
    (if (cond
          ((let ((q1 (if #\h #t (zero? #\U00090ACD)))) #f)
           (cond
             ((if #t #f #f) #t)
             ((let ((g0 (integer->char #\꺌))) -2) (if #f #t 2))
             (#f
              (cond
                (#\䳌 0)
                ((if -2 -6 #\킩) #\U0005C562)
                (-2 #t)
                (#f 5)
                (#\U0001343B #f)
                (else #\U000651CE)))
             ((cond (else 4)) (if 7 0 -1))
             ((let ((g1 #\U0007198E)) #f) (let ((a2 #t)) a2))
             ((let ((u0 #t)) #\퇈) #t)
             (#\U0010AF38 (cond (#t -2) (#f #f) (else #t)))
             (-4 (cond (3 3) (#f #t) (else #\疦)))
             (else (let ((s0 #f)) #t))))
          ((add1 #t) #f)
          (#f (boolean? -1))
          (else #\Ꚅ))
        #t
        #\U000D3B70)
    #\挭
    (if (let ((f0
               (cond
                 (else
                  (cond
                    (#\힟 -5)
                    (#f (abs #f))
                    ((if (if #\U0007287B #f 7)
                         (cond ((abs #f) #t) (else #t))
                         (char->integer #\Ʋ))
                     (char->integer 2))
                    ((if #\U000740ED #\U000FA891 #f)
                     (if #t
                         (if (integer->char #\U000B61EC) #\𥰪 (integer? #t))
                         (cond
                           (#\U0009A90D #\樻)
                           ((integer->char -1) #f)
                           (-1 #t)
                           ((cond (else #t)) #f)
                           (#f #f)
                           (1 (if #f 1 -8))
                           (else (integer? #f)))))
                    ((cond (#\翙 #f) (else #f)) #f)
                    (#t
                     (if 8
                         (cond
                           (#\ⷤ #\U00032F4E)
                           (#\𦥁 -5)
                           (#f #f)
                           ((cond
                              (9 -2)
                              (#t #\₵)
                              (#\U000F22A0 2)
                              (#\腠 #t)
                              (#f #f)
                              (else 4))
                            -4)
                           (else #f))
                         #t))
                    ((if (if #t 2 (cond (else -3))) (cond (else #\㩴)) #\蛇)
                     (if #\U0003ECD1 2 #\U0008231F))
                    ((if (integer? #f)
                         (if (cond
                               (#t #\耿)
                               (#\쎖 #\᱗)
                               (4 #\U000E7889)
                               (16 -4)
                               (#\辵 -10)
                               (#\⻨ #\菻)
                               (#f #t)
                               (#t #\같)
                               (else -6))
                             #t
                             (cond (#t #f) (#\蔂 #f) (#\珷 #t) (#f #\ꨎ) (else #\뵶)))
                         #\U000F04F5)
                     (cond
                       ((if (abs #f) (if #\㑥 #f 0) #\U000C4734)
                        (if (char->integer #\uA9DB) (if #f #f #t) #f))
                       (#\u0D5B -9)
                       ((cond
                          ((add1 #f) #t)
                          (else
                           (cond (#t #\U000A7468) (#\䢭 -5) (#\踧 #t) (else 4))))
                        #\U0001454C)
                       (#f #\U00101A15)
                       (2 (if (integer? #f) (integer->char 5) (if #f #f #t)))
                       (else #t)))
                    ((if -2
                         (if #\较 #t (abs 1))
                         (cond (#\变 (if #\㿪 3 -5)) (else (cond (else #t)))))
                     (if #t #t #t))
                    (#t #\U000DA9B1)
                    (-17 (integer? (if (if 32 #\⢍ #\U000F3039) #t #t)))
                    (#f #t)
                    (#t (if (if (if #\饑 1 #t) #t 6) 33 #\U000EAE8A))
                    (else -2))))))
          #\䡍)
        (integer->char #t)
        (if #f #t #f))
    (integer->char
     (if -4
         (cond
           (-2 #\똙)
           (514 4)
           (-2 #t)
           (#\U0009DED4 (add1 #\포))
           (-1 11)
           ((if #f #\U0003C051 -1) #\ꨲ)
           (#\与 (if #f #f #f))
           (#t #\𧟀)
           (else (cond (3 #f) (else #t))))
         (- (char->integer #t))))
    (cond
      (#\ᣄ #t)
      (#t #\U000F0F55)
      (6 #t)
      ((sub1 #\ꖖ) #f)
      (#t (cond (#t #t) (#f (zero? #t)) (else #t)))
      (#t #\뫟)
      (-1 #t)
      ((if (abs (integer->char #t)) (sub1 #f) (cond (else #f))) #f)
      (1 0)
      (#t (zero? #f))
      (#\U0007421A #f)
      ((if (if #t #\앋 #\𫙟) (char? #t) #\U0001C606) #\U000E6C21)
      (#\U0009A4DB (if #\ཐ (add1 (cond (else #f))) #t))
      (else #f))
    #t
    (integer->char (if -1 (if 8 #t (if #f #t #\U0007898B)) #t))
    1
    #t
    #f
    (let ((n0 #t)) (char? #\壃))
    #\U0001CAFC
    #f
    #t
    (if #\U000CE1E7
        (char?
         (cond
           (#\U000C6743 (if 1 #t #f))
           (#\ൾ #t)
           ((cond
              ((if #t
                   (cond
                     (else
                      (cond (#\𒃛 #\ꐀ) (#f 2) (#\U000EB7B2 #f) (#t 32) (else #f))))
                   2)
               (add1 #\U00010C5B))
              (2 (- (cond (#\U00094BDD (boolean? #\揶)) (else (cond (else #f))))))
              ((cond (else #f)) -3)
              (#t (if #f #\豶 (zero? #\U0009E764)))
              ((if 2 (if (if #\࠵ #t #f) (if 2 #t 2) #f) #\쵰) (- #f))
              (#\U00086D41 #t)
              (#f (sub1 #t))
              (#\ฅ #\U00046679)
              (#t #t)
              ((if (if #t (if #\U000420A5 9 -9) #t)
                   #t
                   (cond
                     (#f #\ꗴ)
                     ((cond (#f #\U00036D87) (else #t)) 1)
                     (else (integer? #t))))
               (if (if 2 (add1 -1) #\U000EDBAF) (if #f #t -2) #\婯))
              ((if (integer? #\죻)
                   (if (cond (else 3))
                       (cond (#t -2) (#f -2) (#t -2) (#f #t) (else #f))
                       #\U000DADBD)
                   (abs #t))
               (if -4 (if (if -8 #\옄 #f) (char? #f) (sub1 #\U00066A44)) #f))
              (#f #f)
              (#\င #f)
              ((if (cond
                     (#\也 #t)
                     ((cond
                        (#t 0)
                        (#f 4)
                        (#f #\⎏)
                        (#t #t)
                        (#f #\쨮)
                        (#\U0004B8D7 #\U00076676)
                        (else #f))
                      (if #\睉 #f #\U0010E5FE))
                     (else 0))
                   (if (cond (#t #t) (#f #t) (else #f)) 4 (integer? -3))
                   (char->integer #t))
               (cond
                 (#\귙 #\U000BE8A9)
                 ((integer? #\U000AC18A) #\U00059609)
                 (-3 #\U000C68D6)
                 (#t #f)
                 (#t #f)
                 ((if (cond (#t #t) (else #f)) #t -5) (if #\簵 (if #\焖 #\扐 #t) #f))
                 (#\U0003D620 (char? #t))
                 ((abs (if #\荜 #t #\㵃)) (zero? #f))
                 (-1 3)
                 (else #f)))
              (-5 #t)
              (#\蓯 #f)
              (#\㰤 #t)
              (#\茩 #\U0007FF64)
              (-3 #f)
              (#t #\멡)
              ((cond ((zero? #\烞) #\텣) (else 0)) 1026)
              (#\浛 #\ሙ)
              (#f 0)
              (else 2))
            -4)
           (#\U000EBA96 64)
           ((sub1
             (cond
               (4
                (cond
                  (#\몳
                   (cond
                     (#t #t)
                     (-6 (char->integer #t))
                     (-4 #\㬛)
                     (#\U000D35F0 #t)
                     (else #t)))
                  ((if (cond
                         (#f #t)
                         (#f -1)
                         (-2 #t)
                         (#t -5)
                         (#\U000DB79C #t)
                         (#f #f)
                         (#f #f)
                         (#t #f)
                         (#t 5)
                         (#t #f)
                         (#t 4)
                         (#f #f)
                         (else -4))
                       (integer->char 2)
                       (if #f -1 #\U00109AC5))
                   #t)
                  (#t #f)
                  ((integer->char (if -2 #\瓹 #f)) -3)
                  (4 (if (cond (#\쭱 8) (else #\鬺)) (if #f #f #f) (if -1 #f #t)))
                  ((cond (#f #f) (else #f)) #t)
                  (else #f)))
               (else #\U0004C4A2)))
            (if #\㵲 #t #f))
           (else
            (-
             (if #f
                 #f
                 (cond
                   (#t #f)
                   (#\㈊ 2)
                   (#f #f)
                   (else (cond ((cond (else -4)) #t) (else (boolean? #t))))))))))
        1)
    (let ((e1 (cond (else (let ((s0 (integer->char -4))) 2)))))
      (let ((k2 (if #t e1 (integer->char 1)))) e1))
    (if (char->integer (let ((z2 3)) (boolean? z2))) #\쳊 35)
    0
    (cond (else #\붏))
    (char->integer -2)
    #f
    (cond (else (char->integer -2)))
    (integer->char
     (cond (else (- (cond (#f -8) (#f 3) (-4 0) (#t #t) (else #t))))))
    #\U000DCEC3
    (let ((j1 -2)) (let ((a2 (char->integer j1))) #\ᕴ))
    #t
    (cond
      (#\· #t)
      ((zero? #t)
       (if 4 (if #\ᤜ #\U000E14D0 #f) (let ((b2 (add1 -4))) #\U000CF8F5)))
      ((let ((c2 (zero? #f))) #f) 2)
      ((char? -1) #t)
      ((let ((y0 2)) (let ((g0 #\U000504D0)) (if #f #f g0))) 3)
      ((cond (else #f)) #t)
      (else (cond (16 #\蚪) (#t (cond (else -2))) (else #f))))
    3
    (if #f (boolean? 2) #t)
    #t
    (cond
      ((cond
         ((cond
            (#f 4)
            (#t #t)
            ((cond
               (#\憻
                (cond
                  ((integer? (cond (else (cond (else -3))))) #f)
                  ((if #\U0008AB6A (sub1 (if #\ᇔ #f #f)) (- 2))
                   (if #t
                       (cond
                         ((if #t 1 #\U0001C136) 1)
                         ((char? #t) (integer? 0))
                         (else #\ᵦ))
                       (cond
                         (#\䀬 (if #f #f #t))
                         ((if -1 4 #\U0005DD8B) (cond (else #f)))
                         (else
                          (cond
                            (#f 2)
                            (#\썽 #t)
                            (#f #f)
                            (-3 2)
                            (-4 0)
                            (#\𩞺 #t)
                            (#f #\U0004DDEA)
                            (2 #\U0003DEC7)
                            (#\쒌 #\U000B49C3)
                            (else -1))))))
                  ((if (cond (else #f)) (if #\程 #f #\U0009503F) #\U000738AB)
                   (if (boolean? (zero? #\ꎦ)) #\缛 (- 2)))
                  ((cond
                     ((cond
                        (else
                         (cond (#f -3) (#f -2) (#f 1) (#t -9) (-2 #t) (else 11))))
                      (zero? #f))
                     ((cond
                        (#\橑 (cond (#\U000B30B6 #\U000FD0A4) (else #\鄭)))
                        ((if #f #t #f) (if 1 #t #\𫍲))
                        (else #f))
                      #t)
                     (-2 #t)
                     ((cond (#t -1) (-3 #f) (else (if -1 #\稠 #f)))
                      (char->integer (cond (1 #f) (#t #t) (else #f))))
                     ((if (cond (#f #f) (#\羷 17) (else 4)) #f (if #f 3 #t))
                      (- (cond (else #f))))
                     (else #t))
                   -2)
                  (-9 #t)
                  ((if (cond (#\𐫙 (if -4 #t #f)) (else #t)) #\𝚅 #f) -42)
                  (#f (if #f #\戂 (cond (else (cond (#\U000517F3 #f) (else #f))))))
                  (#\U000E0E97 (- (if (boolean? #t) -2 #f)))
                  (else #\렴)))
               (#f #f)
               (-1
                (cond
                  ((if (zero? #f)
                       (if #t
                           (cond
                             (#f #\U0009DE17)
                             (#\憲 0)
                             (4 #\U00016061)
                             (else #\U00034AA0))
                           #t)
                       #t)
                   6)
                  (1 (integer? #f))
                  ((if (boolean? #t) -2 #f)
                   (cond
                     (#f -1)
                     (-2
                      (if #f
                          (cond
                            (#f 9)
                            (#f -68)
                            (#t 4)
                            (#\ᘛ #t)
                            (#t #t)
                            (#t #f)
                            (#t #\癏)
                            (#t #t)
                            (#t #f)
                            (#f #t)
                            (#f #\U0006FA75)
                            (#f #f)
                            (#f #f)
                            (#\U001050CB 6)
                            (else #f))
                          (cond
                            (#t -1)
                            (#\U000725D8 -7)
                            (#\둓 #f)
                            (#t #\U00084CA2)
                            (#f #t)
                            (3 #f)
                            (4 #t)
                            (#\U000E6F92 #\棷)
                            (5 #f)
                            (-2 -5)
                            (2 #t)
                            (#f 1)
                            (#t #\U000DB960)
                            (else #\U0004628D))))
                     (#t (if #f (cond (else #t)) #t))
                     (else 0)))
                  ((boolean?
                    (cond (2 -1) ((boolean? #f) -4) (3 #\U0003CEE5) (else -4)))
                   (if #f (integer? #f) #\U000E332C))
                  (-4 32)
                  (#t (sub1 (add1 #\伿)))
                  (else #\U00040BAD)))
               (#\䔿 #\맷)
               (else #f))
             (if #t #f #\䋧))
            ((cond
               ((if (cond (#f #\䠼) (else #\ᮤ))
                    (if #f #t #f)
                    (char->integer #\U000B870A))
                -8)
               (else (char? #t)))
             #\䌾)
            ((zero? #t) (if #t 2 #f))
            (#t (char->integer (sub1 #\桻)))
            (#t -34)
            ((if 9
                 1
                 (if (cond (else (boolean? (if #t #\꺺 -1))))
                     #t
                     (cond
                       (3 #f)
                       ((integer? #t) (cond (else #\궃)))
                       (#\U0007BD08 (cond (else #f)))
                       ((cond
                          ((add1 #t) #\↣)
                          ((zero? #\U000BB63E)
                           (cond (#t #t) (#\쫑 #f) (#f 2) (else #\쀝)))
                          (#\U00065028 (if #f -9 #\U000D51B4))
                          ((if #\U0004D37A #f #f) -1)
                          (else #t))
                        (char->integer #t))
                       (#\ᕨ (- (integer? #t)))
                       (#f #t)
                       (else #f))))
             (if (cond
                   (#t #\፬)
                   (-1 #f)
                   ((cond
                      (#\䃛 -3)
                      (#\U000CEC2F (cond (5 #\잉) (else #f)))
                      (0 #t)
                      ((if #t #t -5)
                       (cond
                         (#t #t)
                         (#\U000FF1CF 1)
                         (3 #t)
                         (-5 #\隡)
                         (0 #\U000B9C02)
                         (#\鳚 #f)
                         (#f #\儜)
                         (#f 2)
                         (2 #f)
                         (2 #\멧)
                         (else -9)))
                      ((integer->char #f) -1)
                      (-9 (integer->char #f))
                      (4 (cond (else #\U000E11D1)))
                      ((if #t -2 #\U000CD975) (char? #f))
                      (else 4))
                    #f)
                   (else #f))
                 (if -2 #\䍿 #f)
                 1))
            (else (add1 -17)))
          (boolean? #f))
         ((if #\䠤 (- #t) #t) (if #f -4 #\坻))
         (else #f))
       -2)
      (#f #\䢠)
      (2
       (cond
         (#f (if (if 3 #\U00067B3E #\U0001B714) (if -4 #\U000B5E31 #f) #t))
         ((char? #t)
          (cond
            (#t #\뙑)
            (#t (cond (#\䭨 #t) (else -2)))
            ((if #t 0 #\U000FA1A9) -1)
            (#\̝ #t)
            ((char->integer #t) 5)
            ((boolean? #t) (abs 6))
            (else #\U00036D5B)))
         ((if #f
              (integer->char
               (if (char->integer #t) -5 (cond (#\䯌 #\U000C64D3) (else -2))))
              4)
          (- #\U0008EC0B))
         ((if (if #t (char->integer #t) (sub1 #f))
              (if (boolean? #t) #\▜ #t)
              (cond
                ((- -10)
                 (cond
                   (else
                    (cond
                      (#\싦 #f)
                      (#f #\U000E114C)
                      (#t #\U00106139)
                      (#\U000DA7E4 #t)
                      (#t #t)
                      (#f #t)
                      (else #f)))))
                (#f #\U000198A3)
                (#t 5)
                ((sub1 #\魜) (zero? (cond (1 #\U00072758) (#\쩎 #\u12BF) (else 5))))
                (#\䒮 (zero? (char->integer #t)))
                ((zero? (if #\켷 #t -4)) #t)
                (else #f)))
          #t)
         ((cond (#\綎 #f) (#f (if (add1 #f) #f 3)) (else #f)) -8)
         (#\Ṛ (boolean? -1))
         (else #f)))
      ((cond
         (#\U000B673D #f)
         (#\U0001E2AA 7)
         (#t #t)
         ((zero? #t)
          (if (cond (else #t))
              (cond
                (#f #f)
                (#t (- #t))
                ((if #\U000E865A #t #t) #f)
                ((cond
                   ((char? -1) #f)
                   (#f -4)
                   (else (cond (#t -3) (#t #f) (else -67))))
                 129)
                (4 20)
                (#\㭾 #t)
                (#\U0001DCCA (sub1 #t))
                (#\壁 #f)
                (else #t))
              #t))
         (else 0))
       (cond (else (let ((b2 0)) (cond (#f #\U000B309C) (else b2))))))
      (#\팂 #t)
      (#\ᓅ -2)
      ((if (cond (#t (integer->char 0)) (else (cond (1 #\䈞) (else #f))))
           #\U0010E37C
           #f)
       1)
      ((add1 5) 0)
      ((char? #\𖡿) #\U000CAF5B)
      ((let ((l2
              (if #\᎓
                  (cond
                    ((cond
                       ((if 4 (if #t #f -4) #t) #f)
                       ((boolean? (if #\쁅 #\縗 #\U0009D2FA))
                        (cond
                          ((if #f #\U000CFDCD #t) (zero? #\U000774C2))
                          (-1 #t)
                          ((cond (#\톬 #f) (#t 1) (#f #\훪) (else #\䐄)) #t)
                          (else #t)))
                       (#f #t)
                       ((cond (#f #\ƒ) ((cond (else #\헷)) #\u0098) (else #t))
                        (zero? (if #t #\U000F347E -3)))
                       (#f
                        (cond
                          (#f -2)
                          ((if 5 #f #t) 3)
                          ((sub1 #f) (char? #\⊉))
                          (#f (add1 2))
                          ((sub1 #\U000F0B97) 2)
                          (1 1)
                          (#\当 (cond (#\껾 #f) (else #\埁)))
                          (else #f)))
                       ((if #\U000C1694 #f (boolean? #\궳)) 3)
                       ((integer? (if #\U0007CB95 1 2)) #t)
                       (#f #f)
                       (else (- (cond (2 #f) (#t #t) (else #\U001036B4)))))
                     (cond (else (abs 2))))
                    ((cond
                       (#f (integer? (cond (#\U0008682A 2) (else #\U000637A1))))
                       (3 #f)
                       (else (add1 (cond (else #f)))))
                     #t)
                    (else #f))
                  (if #t #f 8))))
         #t)
       #\uE023)
      (#t (let ((k1 #f)) 10))
      (#\궐 (cond (-1 -17) (else (sub1 #\U00067ED1))))
      ((if 5
           #f
           (cond
             ((cond (#f #t) (else #f)) (if #t #t #t))
             ((if (add1 #f) #\썁 #t) #t)
             ((let ((d1 #t)) #t) (if #\u1739 #f (abs -2)))
             ((cond
                (#t #t)
                ((if 5
                     (integer->char (if #t #\訟 (cond (else #f))))
                     (cond
                       (#f #\㯺)
                       (#t (integer? (integer? #\U000E49FD)))
                       (#\U000FFCD3
                        (cond
                          (#\飬 #t)
                          (-2 (add1 2))
                          ((integer->char #t) (- #t))
                          (#t (char->integer #f))
                          (-2 #\Ĺ)
                          ((abs #\䢨) #t)
                          ((cond
                             (#f 2)
                             (-2 #f)
                             (-1 #t)
                             (#\ꈖ #t)
                             (#t #t)
                             (#f #t)
                             (#f #f)
                             (-3 #f)
                             (#t #f)
                             (else #t))
                           #\䘾)
                          (#t 0)
                          ((sub1 0) #t)
                          (else (boolean? #\睒))))
                       (#t (integer->char #\U000E9DD9))
                       (#\U0008FB15 #f)
                       (#t #\ꃺ)
                       (#f #\虧)
                       (#f #\U00013BBA)
                       ((char->integer #\U0002C6B1) (sub1 #t))
                       (#f #t)
                       (#\穆 #f)
                       ((cond (else #f)) #t)
                       (else (cond (-32 -2) (else (if #t #f 1))))))
                 #t)
                (-32 #t)
                (else #f))
              #f)
             (else (sub1 (char->integer (if (integer? (- #f)) #\U0005B05E 17))))))
       (cond (#t -3) (else 6)))
      (5
       (let ((z0 (cond (#f (boolean? #\U00074FBD)) (else (integer->char #f)))))
         (integer? #f)))
      ((cond
         ((let ((v2 (let ((v1 #f)) #t))) v2)
          (cond
            (#t
             (cond
               (#t #\U001033E2)
               (#f -9)
               (-2 11)
               (#f -5)
               (#f #\U000162C5)
               (#\U0004C8E5
                (sub1
                 (if (cond
                       (#t #f)
                       (4 (if #t #\楕 #t))
                       ((char->integer #\慏) #t)
                       (#t #t)
                       (-1 (if #f 3 1))
                       (6 (add1 #\踔))
                       (else #\῝))
                     #\᰾
                     (if -2 (if #t #t 3) (if #\U000D29BB #t #f)))))
               (#\U0006685D #\撴)
               (else #\禇)))
            ((cond
               (-3 #\䗌)
               (#\楶 0)
               (-4 #t)
               (4 #t)
               (#t #\U00103A78)
               (2 #t)
               (else 4))
             #f)
            (#\U0006E074
             (if #f
                 (cond
                   ((char->integer #\䝀) #t)
                   (#t
                    (cond
                      ((zero? -3) #f)
                      (#\ꀹ
                       (cond
                         ((zero? 2) 19)
                         (2 #\褭)
                         (#f #t)
                         (#\䕪 #\U000E2F95)
                         (#\䘰 4)
                         ((cond
                            (#\疪 -8)
                            (#f #\U0010AEA2)
                            (#\U00040934 #\U000E8B52)
                            (3 #t)
                            (-4 #f)
                            (#\U0006D517 #f)
                            (3 #t)
                            (#\㛣 #f)
                            (-2 #t)
                            (#f -2)
                            (#\䅸 #\𪅈)
                            (-1 2)
                            (#t #f)
                            (else #\謥))
                          #f)
                         ((if #t 2 #\U000DA016) (cond (else #f)))
                         (#f -1)
                         (else (if #t #t -33))))
                      ((if #t (add1 #f) #f) 4)
                      (2 (char->integer 1))
                      ((cond
                         (#\䩐 (cond (-1 #\U00056411) (#t 0) (#t #\撘) (#t 5) (else #t)))
                         (1 (cond (#\斲 #f) (#f #\U00071D93) (#f #t) (#t #t) (else -5)))
                         (else #\켔))
                       #t)
                      (else #\U000CA1C1)))
                   (#\먒 #\녀)
                   (#t -2)
                   (#t #f)
                   (#t
                    (cond
                      ((cond
                         (else
                          (cond
                            (#t #t)
                            (#\U000AFDE9 #f)
                            (#\U0009FF48 #f)
                            (#\uABB2 #\U000D3600)
                            (else #t))))
                       #t)
                      (#f #\U000C55DF)
                      (2 #t)
                      (#t (boolean? (if #t #\챾 #t)))
                      (#t #t)
                      (#f #f)
                      (else #f)))
                   (4 2)
                   ((integer->char #f) #f)
                   (2 (sub1 (char->integer #t)))
                   (#\U000F903F (if -1 1 (- (abs -5))))
                   ((cond (else (char? -4))) (zero? (abs #f)))
                   ((boolean? #f) (char->integer #f))
                   ((if (cond (#t #\U00012D7A) (else (if #t -3 #\U00087112)))
                        (char? (if #f #\䬪 #t))
                        #t)
                    #f)
                   (else
                    (if #t
                        (cond ((cond (else 3)) (char->integer #t)) (#f #\𣡖) (else 3))
                        #\鍺)))
                 #\U00033646))
            (2 (abs #\ꉜ))
            (#\蚪 #t)
            ((if (cond
                   (#f #\䰯)
                   ((if (if #t #f -1) #f (if #\궅 #f -1)) #f)
                   (#\쎟 (if #f 1 (char? #\ම)))
                   (#t #t)
                   (#t #\U00015152)
                   (#f (if (if -4 #\襵 #t) #f #f))
                   ((if (sub1 9) #f #f) #f)
                   ((integer->char #f) #f)
                   ((if #f #\U0006568D 2) #f)
                   ((char->integer (cond (else #f))) (cond (else #f)))
                   (else #f))
                 (- #f)
                 -1)
             #f)
            ((integer->char #t) #t)
            (#\U0002E017 (let ((z2 #t)) z2))
            (#t 10)
            (else #f)))
         ((let ((e0 #\U0005AFCF)) #\誻)
          (let ((q2 (cond (#t #f) (else #f)))) (if #\䭅 q2 #t)))
         ((- (let ((c1 #\U000E331E)) #\u0BD3)) (integer? (if #f 8 #f)))
         ((integer? #\U00080DE7) 4)
         (#t (char? #\ꍗ))
         (else
          (if 3
              #f
              (cond
                (#\ԉ #\𣌠)
                (#f
                 (cond
                   ((cond
                      (#f #\U00071EAD)
                      (#\U000F4809 (if #t #f -2))
                      ((cond
                         (#t #\U0006F703)
                         (#f #f)
                         (#\U0010A593 -1)
                         (#\U000CF0C1 -2)
                         (#\U0007DC81 #t)
                         (-2 #f)
                         (else #\浴))
                       (if #f #t #t))
                      (2 -3)
                      (#\U00035119 #t)
                      (else (if #t #t #f)))
                    (sub1 1))
                   (else #\㢳)))
                ((if (abs (cond (-2 #\撂) (else -10)))
                     #\ࡄ
                     (if (integer->char #f)
                         (integer->char #f)
                         (cond (#t #t) (#t #\U00061F92) (#f #\瓌) (#t #f) (else #t))))
                 (cond
                   ((cond ((sub1 #t) (if -7 2 #t)) (else 0)) #f)
                   (#f (if (if #f #f #f) 64 (if -128 #t -4)))
                   (else #t)))
                (else -64)))))
       (add1 8))
      (#t
       (let ((j2
              (cond
                (#t #t)
                (#f
                 (cond
                   (#t 0)
                   (#t #f)
                   (-3 #\U000A38C3)
                   (-2 #f)
                   ((zero? -1) #t)
                   (#t (if 35 #t #f))
                   (#\⧓ #t)
                   (#t #t)
                   (#f #f)
                   (#f #f)
                   (#\U000590EA #t)
                   (1 #\廢)
                   (#\U000FC261 (add1 #t))
                   (#t 1)
                   (-16 #\U0004203C)
                   (#t #f)
                   (else #t)))
                (else #t))))
         (cond
           ((cond (#\U0009F159 #\➛) (j2 -4) (#f #\┄) (else #\U000FFA01))
            (boolean? #\U000BB027))
           (5 (let ((s1 j2)) j2))
           ((let ((q0 #f)) #\黡) #\U0001934D)
           (#f (if #\U0007F9CB #\U000A43A3 #\U0010F1DD))
           ((if #f #\U000681E9 #f) (boolean? #\禈))
           (8 (if 2 #f j2))
           ((if -1 #\U00073DF7 0) #f)
           ((cond
              (#t 2)
              (-1 #t)
              (j2 j2)
              (j2 j2)
              (#t 32)
              (#\⪰ j2)
              (2 j2)
              (#t 3)
              (1 6)
              (j2 -17)
              (2 1)
              (#t #f)
              (else #f))
            (let ((n1 #\U00106E8D)) #t))
           ((add1 #t)
            (cond
              (#\U000DB52F #\U0004872C)
              (#f 1)
              (#t #f)
              (#\U00094AE4 j2)
              (#t j2)
              (#f #f)
              (-1 #t)
              (2 #t)
              (#f j2)
              (else j2)))
           (#f #t)
           ((char->integer #\㐝) #\ꟸ)
           ((char? #f) (let ((p2 #f)) #t))
           (#t 4)
           ((cond (#t j2) (#f #\U000F2A76) (#\U0009FAAC #\⢦) (else j2))
            (sub1 #\拆))
           (-1 4)
           ((- #f) (abs #\U0008B54E))
           ((integer->char #f) #f)
           (j2 #f)
           (j2 (integer->char j2))
           ((cond (#t #\U000FD8B0) (-2 16) (else #f)) (integer? #\昼))
           (-65 #f)
           ((integer->char j2) #t)
           (j2 #f)
           (else 2))))
      (#f #f)
      ((cond (else (if (if -1 #t #\ӭ) #t 1))) #f)
      (#f 2)
      ((if (let ((x2 #t)) (if x2 #t #f)) (char? (abs #t)) (boolean? #t))
       (let ((q0 #\励))
         (let ((g1 (if #f #f q0)))
           (cond (g1 #\U000D8C5F) (#f q0) (#f #t) (#t #t) (#t #t) (else g1)))))
      ((let ((i0 #f)) #t) (- #f))
      (#\U0002FFB9
       (cond
         ((if (let ((w2 #\U000579AA)) 2)
              -3
              (if #f (cond (#f #t) ((if #f #t #f) #\U000A4088) (else #\礩)) #f))
          #\U000F8771)
         ((integer->char (- #\U0007E978))
          (cond ((add1 #t) (cond (else #\U0006B343))) (else (integer->char #t))))
         (#t (add1 3))
         (-4
          (cond
            ((cond
               ((cond
                  ((cond (#t #t) (#\U000EB633 #\㌬) (else #\U000303C5)) -8)
                  ((if (cond
                         (else
                          (cond
                            (#f #\U000F7844)
                            (#\凓 #\䛀)
                            (#t -4)
                            (#f #f)
                            (#t #\U00036004)
                            (#f #f)
                            (5 #t)
                            (#t #f)
                            (-2 #\蕨)
                            (#\亢 #\눏)
                            (#f -7)
                            (#\U0006D5C3 #\𤈸)
                            (10 #f)
                            (#f #\U000E2096)
                            (#t #f)
                            (4 #f)
                            (16 #f)
                            (0 3)
                            (#f #f)
                            (2 #t)
                            (else #\駶))))
                       1
                       #f)
                   #t)
                  (else (cond (else 2))))
                (cond ((char->integer -1) #f) (else #\֫)))
               (8 #\U000EE3C0)
               (#\U0003BE13 #t)
               (#t #f)
               (#t #\U000A5C08)
               (else #\⾷))
             (cond (else #f)))
            (#t #f)
            (2 (if #\U000971CF -4 #f))
            ((cond (#f #\U000BFAB3) (8 #f) (else -4))
             (let ((s0 #\錒)) #\U000C32E8))
            (16 16)
            (#f -2)
            (-6 (zero? #\U000CD625))
            (3 (- #f))
            (#f #t)
            (4 #t)
            (else #t)))
         (else #\⚾)))
      (#t
       (if (let ((s2 #\䂃)) s2)
           (if (if #t #f #\U000689AD) #\眸 (if 3 #\훜 #f))
           (cond
             (#\U000849CB (if -4 (abs (char->integer (char->integer 2))) #\餧))
             ((if #f 3 #f) (cond (else #\𪚲)))
             ((integer->char 1) #t)
             (#t (if #\ぞ #\U000F9097 #\U0007F0B5))
             ((let ((n0 #f)) #t) (boolean? #\餴))
             (#f #\U00048B92)
             ((if #\麜 #t #\U0004EBDF) (- 0))
             (-17 (let ((x1 #\྆)) 1))
             ((zero? #f) (if #\U000C1359 #\U000446A3 #f))
             ((let ((g2 (if -1 -2 #t))) #\㶽) #\U00078796)
             (#\U00067699 #t)
             ((integer? #t) #t)
             ((if #f (boolean? #t) #t) (let ((b0 #t)) b0))
             ((cond (-9 #f) (#f #f) (#f #\걉) (#f -1) (else #f)) #t)
             (#\컘 4)
             (#f #t)
             ((abs -5) (if #t #\𠋤 #\搚))
             (#t -3)
             (else (zero? -3)))))
      (#t
       (cond
         ((let ((f0 -5)) 2) (zero? (char? #t)))
         ((add1
           (if (if (char? #\U000E13F9) (if #f 8 #t) #\셭)
               #\黹
               (if (add1 -2) (if #t #t #t) (boolean? #t))))
          #\컸)
         ((cond (else (- #f))) (integer? #t))
         ((if #\停 (if #\U00037C85 #t #t) #f)
          (cond
            (1 -3)
            (#t #f)
            (#t (if #t #\U000AA95C -2))
            ((let ((q1 #\㠏)) #t) #t)
            (else #t)))
         (#f #\햩)
         ((integer? (- #f)) #t)
         ((integer?
           (cond
             (#f 2)
             (#t #f)
             (#\U000569B9 4)
             (#\U0007C440 #f)
             (-1 #t)
             (#f #t)
             (#\U000455DC -1)
             (#f #t)
             (-5 #\觭)
             (#f (cond (#f #f) (#f 1) (else -3)))
             (#\솝 2)
             (else 1)))
          #\U000ED634)
         (#f #\U000DA811)
         (#f
          (cond
            ((add1 #f) #t)
            (7 (add1 #f))
            (#f
             (cond
               (#\忰 #\U0004C125)
               (-512 #t)
               (#t
                (integer?
                 (cond
                   ((if #f #f (zero? 5)) #f)
                   ((if #f #f -1) #\U0006A586)
                   (3 (if (if #\ힿ #t 2) #f 1))
                   (-4
                    (if #t
                        (cond
                          (4 #\᳐)
                          (#\蹛 #\U000AA4B1)
                          (#\𢗼 #t)
                          (0 #f)
                          (#f -1)
                          (#\࣪ #t)
                          (#f #\材)
                          (#t 1)
                          (#t #f)
                          (#f 1)
                          (else #t))
                        #f))
                   ((abs (if #f #\U000D4C1B #\臚)) (sub1 #t))
                   (#\𧟃 2)
                   (else (char? #f)))))
               (7 #f)
               (2 #t)
               (#\U000602DB #t)
               (#f 0)
               (#t 4)
               (else (if #\U000DBD55 (- (char? (add1 -2))) (integer->char #t)))))
            ((if #\䡶 #f #f) 17)
            (#t
             (if (cond
                   (-2 #t)
                   (3 #f)
                   ((if #\U00047491 1 (add1 (cond (else #f)))) #t)
                   ((char?
                     (char->integer (cond (#f #f) (1 #\ۯ) (#\uA7C1 3) (else #t))))
                    #t)
                   (#t #t)
                   ((if #t #t #f)
                    (if #f 1 (cond (#f (cond (else #t))) (else #\U0001DE53))))
                   (else #\ਕ))
                 #\U0006A09D
                 #f))
            (#t 4)
            ((let ((j1 -2)) -2) #\U0009E9AA)
            ((cond
               (-2 #f)
               (#t #t)
               (#t #f)
               (#t (integer->char #\U00035232))
               (else #\뷶))
             (cond
               (#f #t)
               (#f #f)
               (else
                (cond
                  ((if #f
                       (if #\U00037133 #f (integer? -5))
                       (cond
                         (#t #\U0008C212)
                         (#f #t)
                         ((if -2 #t #\U000B33AE) (if #f #f #t))
                         (else #\U000D530D)))
                   #\셸)
                  ((sub1 (if -3 #\U00080E66 (if #f #\뱳 -2))) -3)
                  ((if (if (cond
                             (2 #f)
                             (#\⾁ #f)
                             (#t #t)
                             (#t 3)
                             (#t #t)
                             (#\U000D725C #t)
                             (#f #f)
                             (1 -5)
                             (1 #\튄)
                             (#\䍷 #f)
                             (6 #f)
                             (#t #t)
                             (#\ブ #t)
                             (#f #f)
                             (else #\U000845CF))
                           #t
                           #f)
                       #f
                       #t)
                   -4)
                  (-1 (if #f #\峌 #f))
                  (else #\쌂)))))
            (#t #\긙)
            (else #\U000CA5EF)))
         ((if (boolean? #f)
              (zero? #f)
              (cond
                (-3 (zero? #\ꦷ))
                ((cond
                   (#\ḵ (zero? #\࣯))
                   (#f #f)
                   ((sub1 (if #f #\馋 9)) -1)
                   (#f (integer? (if #t #t #\U000FC0C6)))
                   ((cond
                      (#f (sub1 #f))
                      (#\娸 (cond (#\U0010D1B8 #t) (else -8)))
                      ((if 3 2 #f) #f)
                      ((if #\ᶕ #t #t) (if #t #t #t))
                      (else #\鐬))
                    #\㴧)
                   (#t #\U0009FE94)
                   ((if (cond (#\펚 #t) (#f -10) (else #\몭)) #f (abs #f))
                    (integer? -1))
                   (#\虒 #f)
                   (#f #t)
                   (else (cond (-1 #\U000516CD) (else (if #t #f #t)))))
                 -8)
                (#\ڽ #\U00065A86)
                (#f #\uEFD1)
                (else #t)))
          #\𧵾)
         (1 #f)
         (else
          (cond
            (else
             (abs
              (cond
                (-2 #t)
                ((if #t 16 (- #\U000946EC)) (if (zero? #t) #t #\U0009AEF1))
                (-1 1)
                ((if #t
                     #\U000878B2
                     (cond
                       (#f #f)
                       (1 #f)
                       (#\U00076258 -4)
                       (-3 -2)
                       (#\㕕 #f)
                       (#\U00093692 18)
                       (9 5)
                       (#f 1)
                       (#t -2)
                       (#\뷿 #f)
                       (#t #\U000AE178)
                       (-1 #\U000F6132)
                       (#\䰌 #f)
                       (#t #\軺)
                       (else #f)))
                 (char->integer #\戜))
                (#t (abs #t))
                (#t (integer->char (boolean? #\瑂)))
                ((cond
                   (-11 #f)
                   ((char->integer #\U000D291B) (char? #t))
                   (else (if #t -5 2)))
                 #t)
                (else (if #\쳋 (zero? #\ᷣ) (if #f #\埅 #t))))))))))
      (else
       (if -7
           (cond
             (#f (if #f (integer->char #f) (char->integer #f)))
             ((add1 -4) #\첣)
             (#f
              (cond
                (-3 1)
                (2 (if #\뛳 1 #\姣))
                (#\썘 #\ၪ)
                ((integer->char 1) (abs #f))
                ((integer->char #t) #\琧)
                (#t 2)
                (#t #\뫰)
                ((char? -5) #\uAB1D)
                (else (integer->char 2))))
             ((if (cond
                    (#t 7)
                    (#\퀧 #f)
                    (#t #\钆)
                    (-1 #t)
                    (#t #t)
                    (#\U0009EA81 #f)
                    (#\U000DF22D #\U00060FB6)
                    (#t #t)
                    (-5 #\묛)
                    (#t #f)
                    (17 #f)
                    (else 0))
                  #f
                  #\鵸)
              (if #\퀏 #t (cond (5 #\⇈) (else #\䀔))))
             (#f #f)
             (#f -9)
             (10 (cond (else #t)))
             (#t
              (if (cond
                    (-6 #f)
                    (#f -2)
                    (5 #\坨)
                    (#f #t)
                    (#f #f)
                    (#t #f)
                    (#\ृ #\㺹)
                    (#t 4)
                    (#t #\䐾)
                    (else #t))
                  #\ᣟ
                  (char? #f)))
             (else -5))
           #t)))
    #t
    (if (cond
          ((cond
             (#t (let ((l1 #f)) l1))
             ((cond
                (#\U00075A47 #\靠)
                (#f #\U0001EA14)
                (-3 #\鞞)
                (#f #f)
                (#\U00015A22 #f)
                (1 #f)
                (#f #\U00062EE7)
                (#f #t)
                (#f -8)
                (#f #\U000333C6)
                (3 #\䊢)
                (else #f))
              (let ((s0 1)) 1))
             (else (if #t #\㙿 2)))
           (if #t #t -9))
          (#t (abs #\U000B6B12))
          (else
           (cond
             (#t
              (boolean?
               (cond
                 ((if #t #\U00063EE1 #t)
                  (cond (-2 #t) (#t #f) (#\U00012CBC #f) (else #\ᒆ)))
                 (#t (char? #\瑇))
                 (#f (cond (#t #f) (else -2)))
                 (#\ꨮ #f)
                 (else (if #\㓢 #t #\癚)))))
             (#t (if 4 (if #t #\U00099DB7 2) (sub1 (if #f #\U000E2D91 #t))))
             (else #\౻))))
        #t
        1)
    (cond
      (#f #\婒)
      (#t #t)
      ((cond
         (#t #t)
         (#t (cond (-1 (char->integer #\U0002D615)) (else (if #t -7 #f))))
         (else (cond (#f (if #\U0001575A #f #t)) (else #t))))
       -8)
      (else
       (cond
         (#f (if #f (abs #f) #t))
         ((if #f #\ꡇ #f) #t)
         (#\U000B358B #\𦆺)
         (#f 7)
         ((if (if #\䲀 #f #f) #t -1)
          (if #\U00066900
              #\벮
              (cond (#f #t) (#t #t) (-5 -17) (else #\U000CFC2F))))
         (#f #t)
         (#\U000AA7D8 (if -2 -3 (if -1 #t #\U00075509)))
         (else (if #f #t (if #f #t #f))))))
    #f
    (if 6
        (boolean? #\𪔇)
        (boolean?
         (cond
           (0 (if #f #f (if #t #f -1)))
           (#f #t)
           (#f 2)
           (#t #\U000B8DC1)
           (#f (if #\U0010FC9C #t #f))
           ((cond
              (#\U0008B95F -1)
              (#\⢷ #\씦)
              (#t #t)
              (#t -2)
              (6
               (cond
                 (#f 6)
                 (9
                  (if #f
                      #f
                      (integer?
                       (cond (#t #f) (#t #\U0001604B) (#\쀟 0) (1 3) (else #f)))))
                 ((if #t (integer? #f) (- #t)) (boolean? #\ݚ))
                 (else
                  (cond
                    (-1 (if #f (char? #t) #\⃐))
                    (#\U0004A6C2 #f)
                    (else (add1 (cond (#\괿 #f) (else #f))))))))
              (11 #t)
              ((integer->char (if #t (if #\U0009B188 3 #t) #f))
               (sub1 (cond (else #t))))
              (#f 1024)
              (-2 #f)
              (else (if #\𤜺 #\⦙ #\璿)))
            (cond
              (0 #f)
              (#f 3)
              ((cond
                 (#f #\⸔)
                 ((if #f
                      (cond
                        ((if 1 #\u0560 #t) (cond (#t #f) (#t 256) (#\寭 #t) (else 2)))
                        (else #t))
                      #f)
                  (if -2 (if (abs #t) (add1 -3) (char? #t)) #f))
                 ((char? #\ꥀ) #t)
                 (#f #f)
                 ((if (if #t -11 #\U000BA3BC) -1 #f)
                  (cond
                    (#\͑ 0)
                    (#t #f)
                    (#f (if (cond (else 1)) #t (cond (#f #\ꈒ) (else #t))))
                    ((if 16 (char? #f) (if #f -1 #f)) #f)
                    ((zero? (zero? 1)) 4)
                    ((if #f #t 0)
                     (if (char->integer 4)
                         (boolean? #\獿)
                         (cond (#\U000AD5C2 #t) (#f -1) (else #\㲞))))
                    (#\⠸ #\U00077D3F)
                    ((if #\돯 -1 (cond (#t #t) (#\U0006FA24 #t) (else -8))) -2)
                    (#t #\岵)
                    (5 #\裛)
                    ((- (if #\U000F2F9F #\U000D4C77 #t)) -2)
                    (2 (if #t (if -2 #f #f) #f))
                    ((if (if #f #\U00069905 #f) #t #t)
                     (if #\뀁
                         (cond
                           (1 #t)
                           (#\눩 #f)
                           (#t #\ኝ)
                           (-9 #\얆)
                           (#t #f)
                           (#f #t)
                           (#f #t)
                           (#\콹 #f)
                           (#\U000C04C9 #f)
                           (#f #\♆)
                           (#f 9)
                           (#t #\U0002C9A5)
                           (#f #f)
                           (0 #t)
                           (#t #\촕)
                           (1 #\U000A7542)
                           (2 -2)
                           (#\㈌ #f)
                           (#\鼩 #f)
                           (#t -1)
                           (#t -1)
                           (-1 #f)
                           (5 #f)
                           (else #\uE64A))
                         -9))
                    (#t (if (zero? 36) #\鮛 #f))
                    (#f #\ꂲ)
                    (32
                     (cond
                       ((abs 2)
                        (cond
                          (#t #\U00063FB9)
                          (-2 #t)
                          (#f #t)
                          (-35 #\ᨷ)
                          (#f #t)
                          (#\U00094D65 #\U00108044)
                          (-2 2)
                          (else #t)))
                       ((if #f #\U000E24DC -1) -1)
                       ((- #t) #f)
                       (else (cond (else #t)))))
                    (else #t)))
                 (-5 (char? (char->integer -4)))
                 ((cond (else #f)) #t)
                 (else #f))
               #t)
              (else #f)))
           ((cond (#t #f) (0 4) (#\◖ #t) (else 4)) #f)
           (else (char->integer #t)))))
    (let ((v0 (if 1 #t -2))) #\U000F9CD0)
    #\U000CB707
    (char?
     (cond
       (#\U00105055 (if #\㚰 #f #\U00037A4A))
       (#\읔 #\U000DE72C)
       (else (let ((e2 (if #t #\繑 #\U000D106E))) (if 5 #t -3)))))
    #f
    #\紧
    (-
     (abs
      (cond
        (#t (integer? #f))
        (#\𧼭 #\솔)
        (0 #f)
        ((if #t #\U0004CBEF #f) (if -1 #t #\U0001CC4E))
        ((cond (else #f)) #t)
        (else 4))))
    5
    (char? #\U000EDE2E)
    (boolean? -4)
    (let ((h0 #t)) #f)
    (add1 #\U001098D0)
    #t
    (let ((w0 #f)) #f)
    (let ((c0 (if (- (integer->char (abs #\ꍏ))) -1 #t))) #t)
    (if (if -4 #f #\U000B33AB) #\U00102939 #f)
    (cond
      ((cond
         (#t #f)
         ((cond
            ((if #\渇 (cond (#\綤 #f) (else #\脏)) (if 5 #f -2))
             (abs (cond (else #\膥))))
            (else (- #f)))
          (abs (cond (else (if #f #\㪜 #\؈)))))
         (#f #\U00050482)
         (#\U000BB419 (boolean? (char->integer #\𩈡)))
         ((abs 2) (cond (-64 (if (char? #\U000E3763) 256 #\彉)) (else #f)))
         (-2 (integer? #\땿))
         (else
          (if (cond (else (if -2 #f #\U000F3A99)))
              (cond
                ((char? #\♄) #\ㄘ)
                ((if #f #f #\㲮) (integer? #t))
                ((if #\Չ #f #t) (char? #f))
                (else 10))
              #t)))
       #t)
      (else
       (char->integer
        (let ((s1
               (abs
                (if (if (boolean? #\䦝) #f 2)
                    (if (cond (#t #\U00011E62) (else #t))
                        (- #\U00074427)
                        #\U0010C682)
                    (sub1 #\敶)))))
          (if s1 #\奇 #\U0002ECA5)))))
    (char? #f)
    #\펙
    -2
    (integer->char
     (cond
       (#\U0002E082
        (cond (#f #f) (#f (sub1 #\𖢞)) ((add1 16) (integer? -2)) (else #t)))
       (else (sub1 (char? #\贿)))))
    #t
    (cond
      ((cond (else (let ((d2 #f)) (let ((h1 #t)) #\䯌)))) #t)
      (6 (integer->char 5))
      (1 (char? (cond (else (char->integer #t)))))
      (#\U000401F0
       (if #f
           (if (integer?
                (cond
                  (#f (abs (cond (#\崵 -2) (#t #t) (else #t))))
                  (#t (boolean? #f))
                  ((if #\威
                       (if #t
                           (cond (-3 #\U00108B90) (#\ᐦ #f) (else #t))
                           (integer->char #f))
                       (add1 (cond (2 #f) (#\U000E44EE #\⅌) (else #\㝄))))
                   #\U000A8A11)
                  (#f -1)
                  (2 #f)
                  ((char->integer (boolean? #f))
                   (if (if (add1 #\랞) #t #t)
                       (cond (#t 5) (1 #t) (-2 (if #t -3 #t)) (else #f))
                       (sub1 (cond (-16 #f) (#t #f) (#\U000C838C #t) (else #\鱱)))))
                  (#t #\愠)
                  ((if #t #f #t) #f)
                  (else #\闟)))
               (if #f
                   #\U00100215
                   (if (if #t
                           (if (if #t #f -1) #\U0005E5F0 #f)
                           (if (if #\穲 #t #t) (boolean? #\蹖) -1))
                       #\⠛
                       (if (integer->char 8) -2 #f)))
               #f)
           (zero? #t)))
      (#t 0)
      (-9 #t)
      (else #\䲸))
    #t
    #t
    #t
    (- (- 2))
    (cond
      ((cond
         ((cond
            (#f
             (if (cond
                   (2 (if #f #\훃 (boolean? (add1 #t))))
                   ((if 1
                        (if -8 #t -2)
                        (cond
                          ((cond (#t #t) (#\ᶦ #t) (#f #f) (else #t)) -3)
                          ((cond (#t #t) (#t #\༑) (else #t)) #\豝)
                          (#\U000F9DCE -8)
                          ((boolean? #\腼) #t)
                          (#t #\U000C3E38)
                          ((if #\U000111E0 #t #\U000CD1D4) 8)
                          (#f (if #f #\U00078D00 #\奔))
                          (else (add1 #\U00044BE8))))
                    4)
                   (#\U000D2C5D -3)
                   (#t #\ꖆ)
                   ((add1 #\孓) #f)
                   (#f -3)
                   ((cond (#\U000AC2BE (char? (if #\U000D2EBA -1 -3))) (else #t))
                    #\芗)
                   (#t #t)
                   (#f #t)
                   (-2 #t)
                   (else #\U00097C85))
                 #\U000F2807
                 -6))
            ((let ((o2 #f)) -2) (let ((l1 3)) #t))
            (else (integer? #f)))
          (let ((y0 #\U0007746A)) (if #\≔ #\U00096418 #t)))
         ((if #t 4 #\Ϩ) (if #\U0010373C #\U00042962 #f))
         ((cond
            (-6
             (char?
              (cond
                ((if 1 #t #t) #f)
                ((if #f #f #\U000AD96A) #t)
                ((cond (else -1)) (cond (#f #\⸋) (#f #t) (else #f)))
                (#f (- #\莵))
                (#t #t)
                ((if #t #f #\u20CF) #t)
                ((if -2 1 #t) #t)
                (else (cond (-6 #\俬) (#t 0) (else #\ᗄ))))))
            (#t (cond (#f #f) (else (abs (if #\U0010DA30 -34 3)))))
            ((if (- #t) #t 1) #\됍)
            (#f
             (cond
               (#\U000C0962 #f)
               (#\ᣧ #t)
               ((boolean? #f)
                (if (cond
                      (#f 1)
                      (#t 0)
                      (#f -1)
                      (#\uE980 #\u0601)
                      (4 #\담)
                      (else #f))
                    -16
                    #t))
               ((sub1 (integer->char #f)) (cond (else (cond (else #t)))))
               ((if (if #t #t 2) 4 #t) #f)
               (else (- (char? -4)))))
            ((if #f
                 (cond
                   (#\葫 #t)
                   ((char->integer #t) -2)
                   ((if #\U000D4CFE #f #t) (- #f))
                   ((char->integer 1) #t)
                   (#f (if #t #t 1))
                   (#t #f)
                   (#\ꅬ (boolean? #t))
                   (else #\ඡ))
                 #\ֵ)
             (char->integer #t))
            ((if #t
                 (if #t (cond (#\U00045319 #t) (else #f)) (if 3 #f #\U000D0F99))
                 (- #f))
             #f)
            (#\U000F5361
             (integer? (if (cond (3 5) (else #\⮚)) #t (cond (else #\吣)))))
            (2 1)
            ((char? #f) -2)
            ((cond
               (#\𦹡 (cond (#\⩂ #\U0003ADFD) (else #\憯)))
               ((if #t (cond (#f 3) (-4 #t) (else #t)) #f) #\푐)
               (#f #f)
               ((sub1 #t) #t)
               (#f -2)
               ((if (char->integer #f)
                    #\⟛
                    (cond
                      (#t #f)
                      (-17 #f)
                      (#\ݰ #\𡇊)
                      (#f 5)
                      (#f #\剛)
                      (#\U000413F5 #f)
                      (else #t)))
                (cond
                  (0 #f)
                  ((cond
                     (#t #t)
                     (#\髍 5)
                     (#f #\U0002CB41)
                     (#\𥲠 #f)
                     (#\U000E24C2 4)
                     (#f #f)
                     (#\U00047EB3 3)
                     (else 2))
                   #f)
                  (#\U0001960B #\U00050716)
                  (#f #\␘)
                  (#f 1)
                  ((cond (6 #\U0002FAF3) (2 #f) (#t #\ߎ) (#f #f) (else #t)) #\袨)
                  (else (if #f #t 1))))
               ((add1
                 (cond (-6 3) (#\퓶 #f) (#\𪖠 #f) (#f #t) (#t #f) (#f 2) (else #f)))
                -1)
               (3 1)
               (#t #f)
               ((if (if #t #f 9) #f (if #\㮉 -4 -3)) (cond (else #f)))
               (#f (zero? #\欫))
               ((- #t) #\U000375A6)
               (#\U000904E5 #\땼)
               (#f (if (cond (#f -1) (#\䕺 #f) (else #t)) #t 2))
               ((cond
                  (#t (if #\U000393AB #\ꆼ #f))
                  (1 (cond (#\𐂄 #t) (#t #f) (1 #t) (else #f)))
                  (else #f))
                #t)
               (else 3))
             4)
            (2 #\웩)
            ((char? #t) 2)
            ((if #\╏ #\슣 11) 3)
            (-6 #f)
            (1 #f)
            (#f 0)
            (#\㏉ -1)
            ((integer? (integer->char 2))
             (cond ((if #f 4 #\U000FB39A) #f) (else #\U0006858E)))
            (#t #t)
            ((cond (#\軅 #\븊) (else #f)) #t)
            (#f #t)
            (else (integer? 11)))
          #t)
         (#t #t)
         ((if (if #\U000C27A6 -3 3) (abs #t) (let ((h0 #t)) #f)) #\U0007956B)
         (#t #\U00092FBB)
         (#f (if (zero? #f) (if -2 -4 #f) #\U000DC4FE))
         (else
          (let ((o0 #f))
            (cond
              (o0 o0)
              (#\핓 #t)
              (o0 #t)
              (#\𠩙 #t)
              (#\U0009B989 #f)
              (-2 #t)
              (#t o0)
              (0 #t)
              (#f #\㮩)
              (#\卪 o0)
              (-2 #f)
              (else #f)))))
       -5)
      ((char->integer
        (- (cond (#f #\U00078EB8) (#f #\U000EAFD9) (-3 #\U000A0B3F) (else 2))))
       #t)
      ((cond
         ((integer? (char->integer #\U00083FB1)) #\U000C3948)
         (#f #\ꀸ)
         ((let ((x0
                 (if 0
                     2
                     (cond
                       (#f (- (- 1)))
                       (#f
                        (cond
                          (#f (cond (else (if -2 #f #\U000448EA))))
                          (-4 (sub1 #f))
                          (#\U000C60EF 2)
                          (4 #\U0008B551)
                          ((cond
                             ((cond (else #\U000E1838)) (- #t))
                             (-2 (if #\觳 3 #f))
                             (else #\ꆤ))
                           #t)
                          (#f (char->integer (if #t #t #\U000920D7)))
                          ((if (abs -1) #\U000E11AA #\䭋) 3)
                          (#t #\㘤)
                          (#t (if #t #t (boolean? #f)))
                          (else
                           (cond
                             (#t (cond (#f #t) (0 #f) (#\쓶 #t) (else -2)))
                             ((zero? #f) (if #f #t #t))
                             (else #f)))))
                       (else #f)))))
            #\ّ)
          (cond
            (#f #f)
            ((cond (else #\✔)) 1)
            (#f (cond (else #t)))
            (#f #\䬲)
            ((cond
               ((abs #f)
                (cond
                  ((cond
                     ((integer? #t) (if #t #t #\ȿ))
                     (else
                      (cond
                        (#f -1)
                        (#t #\ᛇ)
                        (#\똝 #\굆)
                        (#t #t)
                        (1 #t)
                        (#\斈 #f)
                        (else #t))))
                   (if #f #t #t))
                  ((if -1 2 (- 2)) -1)
                  (else #\U000B99FE)))
               ((integer->char -3) #t)
               (else -4))
             (add1 #t))
            (else (cond (#t #f) (else #t)))))
         (else (let ((e0 (let ((j0 (add1 #\U000A816C))) j0))) -4)))
       4)
      ((let ((h2 #\㽤)) h2) #\ው)
      ((boolean?
        (cond
          ((cond
             (-1 #t)
             (-3 -64)
             ((cond
                (-17 #f)
                (#f #t)
                ((cond (else (if #t (char? #\먦) #f)))
                 (add1 (if -1 #t (if #t #\鶡 #f))))
                (else #\㌑))
              #\䓚)
             (#\ꟺ #\嵒)
             (-3 #\辥)
             (#t #t)
             (#t #t)
             (-2 #f)
             (1 #t)
             (#\畈 #f)
             (#f #t)
             (#\巫 (if #\U000A4238 #f #t))
             (#f #\U000DEE0F)
             (-2 -3)
             (#f #t)
             (-2 #f)
             ((if (cond
                    (#f (boolean? #\啄))
                    (#f
                     (cond
                       (#t
                        (cond
                          (#t 1)
                          (#\𩿡 1)
                          (1 #f)
                          (2 #f)
                          (128 #\U0002DE9F)
                          (#f #t)
                          (2 4)
                          (else -12)))
                       (else #\U000878C1)))
                    (-2 #f)
                    (#t #\镂)
                    (else #f))
                  #t
                  (cond (#t -1) ((integer->char #f) #t) (else #f)))
              #\U0005B39A)
             (#f 4)
             (#f #\𢾝)
             (#f (cond (#f #\U000CE00C) (else #\ᷠ)))
             ((abs (cond (else #\U000C24C5)))
              (if 1
                  (cond (else #t))
                  (if #\U000F5FA8
                      (if -9 (if #\U00044620 #\媇 #f) #f)
                      (if #f 0 (cond (#\U000E1939 #\U0005E724) (-2 1) (else #t))))))
             (#f #f)
             (#\U000425E0 #t)
             (#f #f)
             (#f 2)
             ((if #f -3 (boolean? #\U0002FCF0)) #\U000D1BEA)
             ((cond
                (-2 (if 4 #t -8))
                (#\辋 1)
                ((cond
                   (#t #t)
                   ((if (abs #\U000FCAA1) (abs #t) (if #\U00093871 #t #\U000D22BD))
                    -2)
                   (#t #t)
                   (else (integer->char -3)))
                 -2)
                (#f (zero? #t))
                (else
                 (if (abs -2)
                     #t
                     (if (if #\铘 -5 #\U0006BD76) #\蝖 (cond (#t #\눑) (else -2))))))
              #\U000D977F)
             (#t #t)
             (#\U00050870 #t)
             (-3 #f)
             (#\U000F228B #\믶)
             (1 2)
             (#f #\ㇷ)
             (#t -4)
             (else 1))
           #t)
          ((if #\U0010806C (cond (else (- 4))) #f) #\壖)
          (#t 16)
          (#\U0002C889
           (cond
             (#\U00019E0E #f)
             (#f #t)
             (#\擎
              (cond
                (-1
                 (if (cond
                       (#t #f)
                       (-11 #t)
                       (#t #\U00035DF8)
                       (2 (char->integer #f))
                       (#f #\U000836A9)
                       ((cond (#t #f) (#f #f) (else #t)) (boolean? -2))
                       (-2 -2)
                       (#f (if -2 -8 #f))
                       (#t -2)
                       (else (cond (else #\厶))))
                     #t
                     2))
                (else
                 (cond
                   (#\U0010DEB5 #t)
                   ((sub1 #t) #t)
                   ((cond (#f (if #f 0 #t)) (else #t))
                    (cond (#t #t) (#\ޥ (zero? -1)) (else #f)))
                   (else #t)))))
             (else #f)))
          (#f #f)
          (else #f)))
       #\U000342AE)
      ((cond
         (#t #\𤬁)
         ((cond (else (cond (#t 2) (0 #f) (#f #f) (#\㚳 2) (else #\U0005428C))))
          (cond (#t #t) (else (integer->char #\⓴))))
         ((let ((q2 #\U00065758)) (if #f -1 #\欫)) #f)
         ((cond
            ((sub1 (cond (#t (char->integer #\혓)) (else #t))) #f)
            (-2 (let ((i0 #\U00073388)) #\ᔁ))
            (#t (if 2 #f #t))
            (-1
             (cond
               (#t #t)
               (#\諏 #f)
               (1 #\U0002DB5A)
               ((boolean? (char? (if -17 3 -2))) #t)
               (#f -2)
               (#\₩ #t)
               (else #\㽪)))
            ((zero? (zero? (cond (else #t)))) #t)
            (#\突 #t)
            (#f #f)
            (else #t))
          (abs (let ((i2 #\ⷎ)) #f)))
         (#f (cond (else #t)))
         (else #f))
       (let ((j1 (let ((m0 #t)) m0))) #f))
      ((let ((l1 (let ((c1 (let ((w2 0)) w2))) (let ((t2 #f)) #f)))) 2) #t)
      (#\挟 (let ((k2 -3)) (let ((e2 k2)) (let ((y1 #f)) #\U000C6881))))
      (#\쉠 #f)
      (#f #\䐸)
      (#t (let ((b0 (zero? 1))) (integer->char #t)))
      (else (if (if #\U000965D6 (cond (else #\⳪)) (abs #f)) 3 -5)))
    #\𢠾
    (if #f
        (cond
          ((cond
             ((if #f #f #\uE04D) #t)
             (#\潼 #\U000AA58F)
             (else (cond (#f #f) (#t #\U00101053) (else #\窂))))
           2)
          ((sub1 -2) (cond (#t #f) ((let ((q2 #f)) -8) -1) (else #t)))
          (#t #\U0009ED80)
          ((if -5
               #f
               (if (cond
                     (#f (boolean? #f))
                     (#f (if #t #\뱆 #\襩))
                     (else (cond (else 2))))
                   #t
                   #f))
           #t)
          ((cond
             ((boolean? 14) (if #\U000D0B09 -1 #f))
             (else (cond (#\罰 #f) (2 #\纗) (3 #\먶) (#f 2) (else #t))))
           (cond
             (else
              (cond
                (#\숺 #t)
                (9 #t)
                (1
                 (if (cond
                       (#t (if (if #f #\础 #f) #\U000D04C5 (sub1 #f)))
                       (#t #t)
                       (#t
                        (cond
                          ((cond (else -1)) #t)
                          (else
                           (cond (#t #t) (#\뀻 #f) (#f 2) (#t #\U000691D8) (else 0)))))
                       (4 #f)
                       (#\蓘 (abs 5))
                       (#t #f)
                       ((cond
                          ((char? 5) #\U00084207)
                          ((if #\㯖 #t #\U00087E5C) #f)
                          ((if -4 #t #t) (abs -8))
                          (#f #t)
                          (else (add1 #\U000A168F)))
                        (if (integer->char #t) #t (integer->char #f)))
                       (-17 (char? 5))
                       (else #t))
                     (if 16 (cond (else (integer->char -8))) #t)
                     (char? (if #f (if 3 #\U00093E19 -2) (if -5 #t #t)))))
                (-32 #\냦)
                (else #f)))))
          (#t -4)
          (#f (cond (#f #\ꚷ) (else 2)))
          (else
           (cond
             ((boolean? #t) #f)
             (#f
              (cond
                (#\㙙
                 (if (if #f (add1 #t) #\像)
                     #\U000ABE5D
                     (cond
                       ((zero? (sub1 #f))
                        (cond
                          (#t (if #f #f #t))
                          ((integer->char #f) (if #f #\⊆ 6))
                          (#\U00080396 #\U000AEBC7)
                          (else (if -7 -6 #f))))
                       (4
                        (cond
                          ((boolean? #t) #t)
                          (#\U0010157A #t)
                          (#f (cond (#\U00044DDE #f) (-1 #f) (#t #\鄂) (else #\냬)))
                          (1 #\U001078AE)
                          ((cond (else #f)) (zero? #f))
                          (#t #t)
                          (2 (cond (-16 #t) (else -2)))
                          (-2 #f)
                          ((if #f -4 -16) #f)
                          ((integer? 5) 8)
                          (else (if #\U0003E68A #t -4))))
                       (else 2))))
                (#t #t)
                (#\U0004D712 #t)
                (2 #f)
                (#\U000C4544 #f)
                (#t #\伄)
                ((if (if (cond (else -7))
                         (cond (#f (if #\U00098D26 #f #f)) (else #f))
                         #t)
                     -1
                     (cond
                       (#\闝 #\U000B88DB)
                       (#f (if (char->integer #t) #\U00038ECF #f))
                       ((cond
                          (#t (if #t 2 #f))
                          ((char->integer #\ᒜ) -8)
                          (else (char? -9)))
                        #\U000BCCCA)
                       (#\버 (cond ((boolean? #f) (char? #t)) (else #t)))
                       (-2 (if #\𑣕 (add1 1) #f))
                       ((cond (-11 #f) (#\堼 #\U000B88C8) (else #t))
                        (cond
                          ((add1 -9) (boolean? 2))
                          (#\𦿑 #t)
                          ((if #\U0008955E -2 #\U000DBBAA) (if #f #\몣 #f))
                          (-2 (sub1 #f))
                          ((if #t 2 -7) #t)
                          (else (if #t #f #\쳭))))
                       (else #\U0004ADAB)))
                 #f)
                (#f 16)
                (#t #\㡥)
                (#f -2)
                (#f #f)
                (5 #f)
                (#f #f)
                (#t #t)
                (-2 #f)
                (else #t)))
             (else (char->integer #f)))))
        (let ((g2 #f)) (if -3 #\U000D9EEE -1)))
    (cond
      (else
       (if #\躚
           (let ((f1
                  (cond (-4 -16) (1 -1) (#f #\U000E54C0) (else (boolean? #f)))))
             #f)
           3)))
    (if -8
        -1
        (if #f
            (cond
              (#f #\U0006E432)
              (#t (abs #f))
              (#f #f)
              ((add1 0) #\躿)
              ((boolean? #f) (let ((f0 #t)) #\U0004FD3E))
              (#f
               (cond
                 (#f #\U000ED698)
                 (#t -18)
                 (5 (char? #f))
                 (#t #f)
                 (#f #t)
                 (#f #f)
                 (else #f)))
              ((zero? #\ꊣ) #\U000B8D2D)
              (else
               (cond
                 (#f #\U00062C65)
                 ((if #\U000A450D 1 17)
                  (if (if #t -4 (cond (#\닽 #f) (#\줎 4) (else -3))) (sub1 #t) #\읢))
                 ((if #f #f (char->integer -1))
                  (cond
                    ((if (- #t) -5 (sub1 3)) #\⊶)
                    (#f
                     (cond
                       (#t #f)
                       (#\ꇝ (cond (#\⎊ -1) (else -1)))
                       (#t #f)
                       (#t -3)
                       ((cond (#f #f) (1 #\U000DD94B) (#\U000E215A #t) (else 2))
                        (if 5 #f -8))
                       (-4 #f)
                       (#t #f)
                       (#\u0383 #\籼)
                       (else
                        (cond
                          (#\u206B #t)
                          (#t #\⟚)
                          (#t #\U000A58CF)
                          (else #\U000F1FF6)))))
                    ((sub1 (cond (#\U000B87CB #t) (#t -5) (#f #\㞡) (#f #t) (else -2)))
                     1)
                    (else #f)))
                 (#\𢱘 (if 5 (integer? (if #\U0007D60F #t #t)) #\U0009A1A4))
                 (else (if #f #f 0)))))
            2))
    #t
    (cond
      ((char->integer #t) -2)
      (#\魝
       (cond
         ((if (- #f)
              (cond
                (#\𧯏 -1)
                (#f #t)
                (#t 16)
                (#f #\͡)
                (8 #f)
                (-12 #t)
                (else #\U000F3687))
              (cond
                ((integer->char #f) #f)
                (#t -1)
                (#t #f)
                (#t 5)
                (#\剔 #\퓒)
                (-4 4)
                (#\U00062DFB 4)
                (else #f)))
          -1)
         ((if (if #f 2 (cond (-1 -2) ((- -3) 17) (else #f)))
              #\朾
              (cond
                (#f (boolean? -4))
                ((cond
                   ((integer->char #f) (if -9 #f #\U0004A9EC))
                   (11 #f)
                   (#f 1)
                   (#f (if -1 #\U0010DDEC #\옮))
                   (else (sub1 #f)))
                 (if #t #f #f))
                (#f #\U0007D70F)
                ((if (if #t #t 0) (char? #\U00096780) (cond (#f -3) (else #t))) #f)
                (else
                 (cond
                   ((add1 8) (cond (else #\Ꮪ)))
                   ((cond (else #f)) #f)
                   ((if #\U000D26B4 #\U00094B50 -5) #f)
                   (#f (add1 #t))
                   ((cond (#t #t) (#t #f) (else -1)) (- #f))
                   ((cond
                      (#\ꈷ #t)
                      (#f #f)
                      (#\쮇 #f)
                      (#\ሓ #f)
                      (#\𨶆 #\U000B2671)
                      (#\ꆙ 16)
                      (else #t))
                    (char->integer #t))
                   (#\˄ (add1 #f))
                   ((sub1 #\U00035780) -3)
                   (else #t)))))
          #f)
         (#t
          (cond
            ((let ((q1 #f)) q1) (if #f 32 (integer? (abs #\憜))))
            (else (add1 #\U0010F7F3))))
         (#f (char->integer #t))
         ((cond (else #t)) (cond (-2 (if #f #f #\U000D7A2E)) (else #f)))
         (else #\氭)))
      (3 -6)
      ((if (cond (else #t)) (if #t (if #\U000F9AB8 -1 #\柭) (cond (else -8))) #t)
       (let ((d0 (if #f #f (add1 #f)))) #\안))
      (else (let ((h2 1)) #t)))
    (if 2
        #\U000E214C
        (let ((a1 (if #f (let ((v0 #t)) #f) (boolean? (- 0)))))
          (if (let ((b2 #\ἳ)) 3) #\⠊ a1)))
    0
    #t
    (cond
      (#\፲
       (let ((e2 (let ((a1 #\宱)) (integer? #f))))
         (char? (cond (e2 #\U000E7AA4) (else #t)))))
      (#t
       (if #\䋜
           (cond
             (#\U000E766D #f)
             (#\퐅 #t)
             (#f (if #f #f (if #t #f #f)))
             (#t (if -3 -1 -3))
             ((if #f #t (if -2 -5 #t)) (add1 #\쓏))
             (#\U0010851D #\U000830DE)
             (#\쑊 #\U0009F10A)
             (#\𢋶 -2)
             ((if 0 (if #f #t #t) (add1 #f)) (cond (#t #\Κ) (else (sub1 #t))))
             (#t #\け)
             ((integer? #f)
              (if #t (boolean? #f) (cond (#f #\뽌) (else #\U00104F6C))))
             ((cond (2 (if -1 #t #\U000FE11E)) (else (if #t #\佴 #f))) #t)
             (#\U000A43DD #\䨯)
             (-4 (char? #t))
             (-2 #\瞚)
             (3
              (cond
                ((add1 #t) #\U000BA1CA)
                (#\uF71D (abs #\U00050B41))
                (#t (cond (16 #f) (#\U000ADE1A #\ᆙ) (else #f)))
                (else #f)))
             ((add1 -5) (if #\U000DAFD9 (- 4) #\U00033A1A))
             (#f #t)
             ((integer->char (cond (else -2))) #f)
             (#\U00054767 4)
             ((cond ((char->integer #\뚄) 3) (#t #t) ((integer? #f) #t) (else -1))
              #\눩)
             (else #t))
           (if #t (char? #f) (cond (#f 4) (else #\柾)))))
      ((sub1
        (cond
          ((cond
             (-3 #\U000C4E40)
             (#f #f)
             (#\𪔩 #f)
             ((if #\Ꝋ
                  (if (if (zero? #\U000BD993) #f #\U000AFDC2)
                      (integer->char (cond (else 3)))
                      (cond ((sub1 #t) #\U000C0839) ((if #f #t #t) #f) (else #t)))
                  #f)
              #t)
             (#\ᵨ -1)
             (4 #\筩)
             (else #f))
           #f)
          (#t #t)
          ((- (integer->char #f)) #\完)
          ((if 3 #\𢭗 2) (let ((d1 #\㿀)) #\U0007B7DC))
          ((cond
             (#\⌶ #f)
             (#\U000B4D03 #f)
             (#\剛
              (cond
                (else
                 (cond
                   ((char->integer 4) #t)
                   (#f #\ᖤ)
                   ((cond (#f #f) (#\U00063787 -2) (else #\U000D3DA6))
                    (cond
                      (#t #t)
                      ((sub1 #t) #f)
                      (#\ꚑ #t)
                      ((cond (#\uA95B #f) (#t #t) (#\u0FDF 3) (else #\濷)) #t)
                      (#f #f)
                      (-1 2)
                      (1 8)
                      ((zero? #\蘐) -16)
                      ((if #\U000CA5A7 #t #f) 1)
                      (#\旝 #\U0006B5BA)
                      (-1 #f)
                      (#f (add1 #f))
                      ((cond (#t #\U000714E4) (else 5)) #\U00107CDE)
                      (else 1)))
                   (#f
                    (cond
                      ((if 2 #f 5) -2)
                      (#f (abs #\㚬))
                      (2 #f)
                      ((if 0 #t -2) (char->integer #\U000BBA3B))
                      ((- 10) (add1 #t))
                      (#t (char->integer #f))
                      (#f (if -1 #f 2))
                      (2
                       (cond
                         (10 #\謰)
                         (#\풡 #\U0006771C)
                         (#\穸 #t)
                         (#t #\U0003EADD)
                         (2 #f)
                         (else #f)))
                      (-1 #t)
                      (1 #f)
                      (#t -2)
                      (#f #f)
                      ((char? 4) #f)
                      ((- #\桖) 3)
                      ((char? #\U0010F770) #t)
                      ((cond (#f #\⦣) (-2 #\돏) (#f #\园) (#f #t) (else 2)) #t)
                      (#t (if -1 #\U0003363B -7))
                      (#t (if 2 #\龹 #f))
                      ((if #f #t #f)
                       (cond
                         (#f #f)
                         (#t #t)
                         (-6 #f)
                         (-12 #t)
                         (#\U000A274E -3)
                         (#f #\⏈)
                         (else #\U0007DCD9)))
                      (#\ᔔ #t)
                      (#f (cond (1 #f) (-4 #f) (#f #\ㄬ) (#\U0002E19B #f) (else #f)))
                      ((cond (else #\U00095D8F)) #f)
                      ((if -3 1 #t)
                       (cond
                         (-3 #f)
                         (1 #t)
                         (#t 4)
                         (-1 0)
                         (#t #\U00103346)
                         (-2 0)
                         (#\U0009ED8B #t)
                         (#\U0006EC68 #f)
                         (-1 #\U000904C9)
                         (1 #f)
                         (#f #f)
                         (#\U000FE9C0 2)
                         (else #t)))
                      ((char? 4) #f)
                      ((char->integer #\U000C51BC) #f)
                      (#t #\U000428F1)
                      ((if #t #f #\𑖦) -4)
                      ((if #t #t #f) -1)
                      (#f (cond (#f #\U0010A64C) (else #t)))
                      (#t (if #f #\U00051D2B 2))
                      ((if #t #f #t) #t)
                      (#\U000F1D93 #t)
                      (#f (if #t #f #f))
                      (-9 #t)
                      (else #t)))
                   (#t
                    (if #t
                        (cond (1 2) (#t #t) (5 #\ோ) (#\弯 #\U00084BBF) (else #t))
                        #f))
                   (#f #f)
                   (#\댚 4)
                   ((if #\㬱 (abs #\U000CB01D) #f) #t)
                   (else (sub1 -2))))))
             (else (char? #\U00101C2E)))
           0)
          (#t #t)
          (3 (if #t -3 (if #t #f -2)))
          (else #t)))
       #f)
      ((let ((a0 #\ヿ)) #\U0009A48D)
       (cond
         (#\ʗ -2)
         (#f #\흽)
         (#f
          (cond
            (#t #\혦)
            (1 -3)
            ((abs -1) #\U000762DF)
            (#\諕 #\ꅋ)
            (1 -2)
            ((cond
               (#t #t)
               (#f #t)
               (#\U0009227E #t)
               (-2 4)
               (#f #t)
               (-2 #\U000D17CE)
               (#t
                (if #f
                    #t
                    (if 1
                        (cond (#f #f) (#\U0003D82E -256) (else #\펺))
                        (integer? -3))))
               (0 #f)
               ((cond
                  ((if #f 5 #f) #t)
                  (5 8)
                  ((cond
                     ((if (add1 -2) #\U0004E062 #t) (if -34 #f (if 1 -1 #t)))
                     ((if (zero? #\恿) (if -17 #t #t) #\䝤)
                      (if #t #t (cond (else #\㖞))))
                     ((zero? #\뎇) (zero? #f))
                     (#\U00105C19 #\饎)
                     (#f (cond (else (char->integer #f))))
                     (#f #t)
                     (-4 (char? #\咽))
                     ((if (if #f #\縡 -3) #t (char? #\U00066F23)) 1)
                     ((char? #f) #f)
                     ((if #f #f (if #\U0004FC14 1 12)) #f)
                     (#f
                      (cond
                        ((- -4) (if #f 2 3))
                        (-34 (if #f #t #\辞))
                        ((integer->char -1) (cond (6 3) (else #t)))
                        ((cond (#\˳ -3) (else 16)) #\U0004A2B5)
                        (else 1)))
                     (else
                      (cond
                        (#\锪 #t)
                        (#f (cond (#t 11) (else #t)))
                        (#\U0001E3E1 2)
                        (#t (if #t #t 3))
                        (#\꾗 1)
                        ((cond (-4 #t) (else #f)) (add1 #\葐))
                        (#f (if #\U000AB9A2 -2 #f))
                        ((if #t #t -3) #\펙)
                        ((if #f #\U0010C12E #f) #t)
                        ((zero? #t) (cond (2 #f) (1 #\꿅) (#f #f) (else #f)))
                        ((if #\巕 6 #\U000A10B4) (- #f))
                        (#f (add1 -5))
                        (else #f))))
                   #t)
                  (else (integer? #f)))
                (cond
                  (#t
                   (cond
                     ((cond
                        ((if #t #t 4)
                         (cond
                           (#f #f)
                           (-1 #t)
                           (#f #\U0008FE8A)
                           (#f #t)
                           (-3 1)
                           (else #\숪)))
                        ((cond (#t -6) (else #t)) #t)
                        ((boolean? #t) 2)
                        ((if #\劓 #f #f) (if #\U00102EE2 #\U000B6CF6 #t))
                        ((if 2 #\U0007DA19 2) #t)
                        ((cond (else 2)) (if -1 #t #t))
                        ((sub1 #f) -1)
                        (#t #t)
                        ((zero? #f) -9)
                        (1 #t)
                        (else #f))
                      #f)
                     (else #t)))
                  (#\촐 (if 4 #f #t))
                  ((if #f (zero? (zero? -8)) #f)
                   (cond
                     ((cond
                        (#t (- #f))
                        ((if #t #\컼 8) (char? 0))
                        (#t #\꧇)
                        (2 (cond (else #\㽛)))
                        (else (zero? #\헵)))
                      (cond
                        ((if #\ᵰ #t #f) -4)
                        ((cond
                           (#f #t)
                           (#\姽 #\㲦)
                           (2 4)
                           (5 #f)
                           (#f #f)
                           (#\U000FF77B 1)
                           (#t #\U00034B56)
                           (#\U000A87D1 -8)
                           (#\䂮 #f)
                           (#\U000B0F0E 0)
                           (#f #t)
                           (#f 2)
                           (#t #t)
                           (#t #f)
                           (1 1)
                           (#f #t)
                           (#\鮀 #f)
                           (#f #t)
                           (-4 -8)
                           (-1 -1)
                           (#\埇 3)
                           (-2 -3)
                           (#f #t)
                           (#f -3)
                           (#f #f)
                           (#f -1)
                           (#\㝒 #f)
                           (#\U000B6450 #\U0005F413)
                           (#f #\臉)
                           (else #\ν))
                         #t)
                        ((add1 #\滆) #f)
                        (-6 #f)
                        ((cond
                           (#\U0005E37E 2)
                           (#\䱽 #f)
                           (#f #t)
                           (#\힓 #\U0004DECB)
                           (#t #f)
                           (#f #\渊)
                           (#f #f)
                           (#\U0010FD8E -4)
                           (#\U0006DCE4 4)
                           (1 1)
                           (#t #f)
                           (#t #t)
                           (else #t))
                         #\Ȿ)
                        (#f #\ꁐ)
                        (else #\턘)))
                     ((cond
                        (8 (abs #\U000412EF))
                        (#\딋 (cond (#\U0008FBB5 #t) (#f #f) (else #\昹)))
                        ((if #f #t #\U000BD85F) #\U000AF33F)
                        (#f (add1 #\U00077791))
                        (#f #f)
                        (else (abs 1)))
                      (cond
                        (#t #t)
                        ((char->integer #\鯦) -6)
                        (#\Ꮁ (if #f #\㊋ #f))
                        ((sub1 4) (cond (else 5)))
                        (else #\u2B96)))
                     (else #t)))
                  (#\넁 130)
                  ((cond (else -1)) #\U000FF6E9)
                  (else
                   (cond
                     ((cond
                        (1
                         (cond
                           (-1 #f)
                           (#\뷵 -8)
                           (6 #\는)
                           (-8 #f)
                           (#\䢪 #\U00090D6F)
                           (-8 -18)
                           (#f #\鞲)
                           (#\U000F3010 #f)
                           (#t #\U0010A4A5)
                           (3 #f)
                           (else #t)))
                        (2 #\U000D6D42)
                        (#t #\U0002E798)
                        (else (if 1 #t 0)))
                      #\U00082695)
                     (-3 #f)
                     (else (if #t 1 (zero? -2)))))))
               (#f #t)
               (#t #f)
               (#\벰 #t)
               (#\髨 3)
               (else
                (cond
                  ((char?
                    (char?
                     (cond
                       (#\U0008EB0E #f)
                       (10 -1)
                       (#f #\➬)
                       (#t #f)
                       (#\U000B130E 3)
                       (#f #t)
                       (else #f))))
                   (add1 (abs (if 1 #t #f))))
                  (else #t))))
             (if (if -3
                     (cond
                       (#t #\U000BC69D)
                       (#\꿌 (char? #\瘰))
                       ((if -8 #f #t) 8)
                       (#f #f)
                       ((if -1 #\͙ #\쉏) #\ᩘ)
                       (#t #t)
                       ((sub1 #f) #\U00102246)
                       (else (- #\U0005B650)))
                     #t)
                 #f
                 (cond ((if #t -18 #t) #t) (else #t))))
            (#t #\U0004B97B)
            ((if 1 #\뻋 #t) (if #f #t -1))
            (#t (cond (else #t)))
            (#\㱽 (if -2 -33 #t))
            (else (let ((a1 -3)) #f))))
         (#\U00101B74
          (if (if #\皚
                  (cond
                    ((sub1
                      (cond ((if 1 2 #\U000B76C9) #t) (1 2) (else (if #t #t #\䢾))))
                     (cond (#t #t) (#t #t) (else #f)))
                    ((- #f) 1)
                    ((char? #\憽) -5)
                    (#t #f)
                    ((cond
                       ((cond (else 0)) #t)
                       ((if #t #t -3) #f)
                       (#t 1)
                       ((cond (else #\ꀼ)) #\𡶵)
                       (-4 -3)
                       (1 #t)
                       ((cond
                          ((cond (-3 2) (-3 #f) (#f 5) (#t -2) (else #f)) #t)
                          ((if 2 #f #f) (if 1 #t #f))
                          (#f (if #f #f #\U0001B046))
                          (else #t))
                        #t)
                       (#\U00018FAC #t)
                       (#t #\ꔕ)
                       (#\u0CDC (if #t (boolean? #\U000C6317) (abs #f)))
                       (#f #f)
                       (else #t))
                     #f)
                    ((if -16
                         (integer->char (cond (#t #f) (#f -3) (#t #\ត) (else -2)))
                         5)
                     (cond (else (cond (-1 #\U000F2554) (else #f)))))
                    (-65
                     (integer?
                      (cond
                        ((if #\៓ #f #t) (zero? #f))
                        ((integer->char -5) (sub1 #t))
                        (else (if #\U00045F8B #t #t)))))
                    ((integer? 8) #f)
                    (#t 1)
                    (#\㿹 (char? 4))
                    (1 -3)
                    ((if 7 8 #f) (char? #\햟))
                    (#\篬 #f)
                    (else #f))
                  #\淌)
              #\U000D9ECC
              #\U0006BA7A))
         (#\U000A6825 #t)
         ((cond
            ((let ((u0 256)) #f) #f)
            ((let ((s1 -1)) -5) #\Ĉ)
            ((if (cond
                   (#\U000C6E82 (sub1 (integer->char 2)))
                   (#\掆 #\崨)
                   (#\U0002DAF4 (integer->char (if #\U000D64D4 #t #t)))
                   (#t #t)
                   ((add1 (char->integer #t)) #t)
                   (16 #f)
                   (else (integer? (if #\U000FC869 #t #\瓺))))
                 (cond
                   ((cond
                      ((cond (else #f)) (if #t 3 -7))
                      (#f (if #f #t #\uF1B4))
                      ((if #\U000F5EF3 #\ᎎ #f)
                       (cond (#t #f) (#t #f) (-4 #f) (else #\跌)))
                      (1 #t)
                      (else
                       (cond
                         (#\聺 #f)
                         (#\컪 #\謐)
                         (2 #t)
                         (#\탐 #t)
                         (-1 #t)
                         (-8 5)
                         (#\U000DE033 #\䀶)
                         (#t -4)
                         (-3 #f)
                         (#t #f)
                         (#t #\㕥)
                         (#\U000C8651 #\郷)
                         (else #f))))
                    5)
                   (else #t))
                 -1)
             #f)
            (#\U00068267 3)
            (else (cond (else -2))))
          #f)
         (-9 #\U000C55F7)
         (else #f)))
      ((char->integer
        (if (if #f
                #f
                (if (cond
                      (#t #f)
                      (#\ꈈ (cond (2 #f) (#f #t) (else 1)))
                      ((char? #t) (- #\թ))
                      (else
                       (cond
                         (#\㹐 (if #t #f #\U000BE428))
                         (-6 #\U000556E7)
                         ((if #t 6 #\U0008B6D1) 0)
                         (#f (cond (#f #t) (#t #t) (else 2)))
                         (#t 67)
                         (else #\ퟙ))))
                    (abs #\U000FB277)
                    #f))
            (let ((y0 -9)) #\㣻)
            (let ((q2 #t)) #\巯)))
       #t)
      (else
       (cond
         ((if (if #t #f #f) (boolean? #t) #\U000D497C) #t)
         ((let ((m2 (cond (else #t)))) #t) (if (if #t #\꩘ #t) (integer? #t) #t))
         (-1 #f)
         ((let ((p1 1)) 2) (if #\U000BB38B 2 #\ꃀ))
         ((cond (else #\U0003615D)) -3)
         (2 -3)
         ((sub1 #f) #\U0005AD96)
         ((if (let ((b2 #f)) #\U0009233A) (let ((s2 1)) #\u9FED) #\ଭ)
          (let ((v1 #f))
            (cond
              (v1 -4)
              (#t #f)
              (#t #f)
              (v1 #t)
              (#f #t)
              (#t v1)
              (v1 #t)
              (#t v1)
              (#t #t)
              (#f #t)
              (else v1))))
         (-2 (let ((r2 #t)) #\U00069B88))
         (else #\⡁))))
    #f
    (let ((i0 (boolean? #f)))
      (let ((o2 (char? 1)))
        (cond
          (#f #\䭊)
          (#t #t)
          (#\U000FF6E6 #t)
          (o2 -5)
          (else
           (cond
             (#f #f)
             (#t #\U000E6370)
             (i0 i0)
             (#t #\겅)
             (#\U000D129D #t)
             (#t #t)
             (#\U00013BF9 o2)
             (#\U000A4FDE #\U0009D1BE)
             (-2 o2)
             (#f -1)
             (#\u318F #t)
             (else #t))))))
    (if (let ((g2
               (let ((k0 (let ((e0 #f)) e0)))
                 (cond (#\재 k0) (k0 #f) (else 2)))))
          (cond
            ((integer->char #t) (let ((f2 #t)) #f))
            (#f (let ((m1 #t)) #\U000ADA74))
            (else (cond (else #\䰞)))))
        #\U0007D05D
        #\U000D7D5A)
    (cond
      ((abs 1)
       (if (cond
             (22 33)
             ((cond (2 #t) (#f #\U000EDDF9) (-1 #f) (#f #t) (else #f)) 4)
             (else
              (cond
                (2 #f)
                (#f #t)
                (#t (char->integer #f))
                (-2 #f)
                (#\u0FFB 2)
                (#f #t)
                (#t #\썜)
                (else
                 (if (cond
                       (#\U000FC39A #\U00049861)
                       (#f #t)
                       (#t #f)
                       (#f (cond (else #\뇗)))
                       (else #\㵤))
                     #f
                     (cond (else #t)))))))
           #\憔
           (if #f (cond (#t #t) (-4 #\˿) (else #t)) #\U000B88D0)))
      ((let ((u2 #f)) #f) #f)
      ((integer->char (let ((a2 #\챝)) a2))
       (sub1
        (cond
          ((abs #f) (let ((q1 #\U000D42F6)) -6))
          ((char? #f) (cond (#t #t) (#f #t) (#f #t) (-4 0) (4 #f) (else #\ꌈ)))
          ((let ((d1 #\𖩛)) #t) #t)
          ((if #t #\ఆ #\䲙) (let ((q0 #\╁)) 2))
          (3 #\U000ED15C)
          (#f (cond (else #f)))
          (else (let ((l2 #t)) #\U000F6E2B)))))
      (#t
       (if (-
            (cond
              (#\ᖙ (zero? 1))
              (#t #t)
              (else
               (cond
                 (3 (- #\U000CC36D))
                 (#\U000FD282 #f)
                 (#\熋 (if #f #\U0009331C (if #\꽉 #t (abs #t))))
                 (#t #\䌦)
                 ((if #\u0C5F
                      (cond
                        ((- #\U0010397A) #t)
                        ((if #\㚘 #\U000D28EA #\𡼔) -1)
                        (else (zero? #t)))
                      (sub1 (if #t #f #f)))
                  (cond
                    ((if (if #f #t #t) #f #\膡) (sub1 #t))
                    (#f 9)
                    (1 (if -2 #f (add1 -1)))
                    (else #t)))
                 (#\郎 (if (if (boolean? #f) #f 4) #f (cond (else (if 2 7 0)))))
                 ((integer->char (if #f (if #\쬁 #\U000F70B1 #\츄) #t))
                  (cond
                    (#f -2)
                    ((-
                      (cond
                        (#t #t)
                        (-2 -2)
                        (#\ڜ #\鼷)
                        (#\U0007B2B1 2)
                        (#t #\u0EE6)
                        (else #t)))
                     #f)
                    (else #f)))
                 (else (boolean? -128))))))
           (cond
             (1
              (if #t
                  (char? #\侐)
                  (if (cond
                        (#t #\U000E3C11)
                        (#f 5)
                        (#t #\U00069820)
                        (#\㩂 #f)
                        (#\U000B7245 #\U000C5E47)
                        (else #\㸴))
                      #f
                      (if 1 #f #\龏))))
             ((cond (else #\ᠨ))
              (cond
                (else
                 (if (cond
                       (-1 #f)
                       (#f -5)
                       (#\礢 #t)
                       (16 #f)
                       (#f #\U000501D7)
                       (#t #\筎)
                       (#\龁 2)
                       (#t #\킱)
                       (5 #t)
                       (#\U0002FBD2 #f)
                       (#\U000F4455 #t)
                       (1 1)
                       (#\̢ #t)
                       (-1 #t)
                       (#\礹 #f)
                       (-2 -7)
                       (#f -21)
                       (#f -1)
                       (#t #t)
                       (#\U0007A305 #f)
                       (#t #\嘁)
                       (#f 5)
                       (#\U0003316A #f)
                       (#\U0001BB2F #f)
                       (#\U000ECA51 #\U000FD5C7)
                       (else 3))
                     #\U00046F5E
                     -4))))
             (#t 1)
             (#t (if #f #f #f))
             (else #f))
           #\𪱶))
      (#\鲣 #\′)
      ((if #t #f (cond (#\皌 (- #t)) (else #f))) 9)
      (#\U0004393B (let ((b2 (- 9))) (cond (b2 #\턺) ((- -4) #f) (else #f))))
      (#f
       (if (if #\𪮲
               (cond
                 (#f #\揨)
                 ((integer->char #f) 4)
                 (#t #f)
                 (#f (if #f #f #f))
                 (-6 #f)
                 ((if 6 -1 #t) #t)
                 ((char? #\䶞) #t)
                 (else #f))
               #t)
           -4
           (char? (integer->char #\U0007E423))))
      (else
       (if (cond (#\怏 (let ((c2 -2)) #f)) (4 #f) (else 4))
           (char->integer
            (if #f
                (if #t
                    (cond (#\U0007DAD4 #t) (else #f))
                    (char->integer #\U000CEF12))
                #\U000DDF28))
           (integer? #t))))
    5
    2
    (cond
      (#\uAACC
       (integer->char (let ((j0 (let ((k1 -2)) #f))) (let ((f2 #t)) f2))))
      ((let ((p1 #f)) #\抹) (let ((i0 (let ((p2 #t)) #\ꖮ))) (if (abs i0) i0 i0)))
      ((if #f
           #t
           (cond
             (1 #\U000C3A2A)
             ((integer? (if #t -3 #t))
              (cond
                ((boolean? #f) 1)
                (#\U000EADF1 #\긔)
                (#t #\U000E30E9)
                (#f -5)
                (3 -3)
                (#f #\U000E5CED)
                (#t 4)
                (-2
                 (boolean?
                  (cond
                    (#f #t)
                    ((if #f (if #\U00055544 5 #f) #t)
                     (if (- -3)
                         (if -1 -2 #\ള)
                         (cond
                           (#f #t)
                           (1 #t)
                           (#t #\㏛)
                           (#t -2)
                           (#t #\U0001C248)
                           (else #f))))
                    (1 #\U000AC247)
                    (#t #\⢍)
                    ((abs (char->integer #t))
                     (abs (cond (-3 #\䦵) (-2 #t) (2 #\断) (else #\ฃ))))
                    ((integer? #t) #f)
                    (-2 (if 8 -5 (if #\U000A9CF9 #f #t)))
                    ((abs
                      (cond
                        (#\U000B75F4 4)
                        (#f #f)
                        (-2 #\ꔄ)
                        (#\⟞ #\U0003F044)
                        (#f #f)
                        (#f -32)
                        (1 -5)
                        (#\U0006915D -4)
                        (else #t)))
                     (cond
                       ((sub1 2) 1)
                       ((cond (2 2) (#f #f) (else #f)) #t)
                       (#f #\窄)
                       (else 34)))
                    ((if #t
                         #t
                         (cond
                           (2 -2)
                           (#t #t)
                           (#\uF3A7 #t)
                           (#\U000D3FCD #t)
                           (#t #t)
                           (else #f)))
                     #\楂)
                    ((sub1 #f) 2)
                    ((if (if 2 #t #f) #\扸 #t) (if (sub1 9) (if 3 #t -4) #t))
                    (#t #t)
                    (else (if #t #t 1)))))
                (#t #\孨)
                (-2 3)
                (-6 #f)
                (#f #\U0008DA00)
                (#\U0007E315 #f)
                (#f #f)
                (-3 #f)
                (else #f)))
             (#f #\U000A6257)
             (else #f)))
       (if (- #f)
           #f
           (if (let ((u2 #f)) #\㖋) (let ((i1 #\U000CAE91)) #\uF244) #t)))
      (else #f))
    (char? #f)
    (cond
      ((if #f
           1
           (if (cond (else #f))
               (cond (#f #f) (#\U00067CC6 #\U00016FDF) (else 1))
               (if #f -17 #\⻣)))
       #f)
      (else #f))
    (cond
      ((zero? #f) #t)
      (#\翈 (let ((v2 16)) #\U000EFA5A))
      ((cond
         (#t (if #\荏 (let ((h2 1)) #f) (if #t #\̓ 2)))
         (#t -5)
         (else (let ((u2 #t)) (let ((c0 #t)) u2))))
       (cond
         (#t 2)
         (#\拨 (cond (else (if 1 (cond (else #f)) (integer->char #t)))))
         (#t (sub1 (char? #\U0009DDA0)))
         (else
          (if (if (if #\U00105245 #t #f)
                  (cond (#f -2) (-2 -2) (#t #\릝) (else 3))
                  (integer->char #f))
              #f
              (boolean? -1)))))
      (else
       (cond
         (#f #f)
         (#f #\U00060941)
         (3 (let ((m2 #\ᕊ)) (if #f #\곏 1)))
         (else #f))))
    (cond
      ((cond
         (#\U000D7857 #f)
         (#\U0005229D #\脂)
         ((integer->char #t) #t)
         ((cond
            (#t #\U000E3A53)
            (#\놾 (let ((n2 #t)) #f))
            ((cond
               (#t #t)
               (#f #f)
               (-1 #t)
               (#f #f)
               (-5 #f)
               ((if #\摇
                    (if #\剨
                        (cond
                          (#f #\U000EF066)
                          (#t (if #f #t #t))
                          ((if #f #f #\U0007A394) (cond (#t #\尽) (else #f)))
                          (else -4))
                        (char->integer (if 4 -2 #t)))
                    #f)
                #t)
               (#t 2)
               (#f #\U0007D965)
               (#f #\U0005A59F)
               (-1 2)
               (#f #f)
               (#t -3)
               (#f
                (if (cond
                      ((cond (#f #f) (#t 0) (else (if 2 #f #f)))
                       (integer->char
                        (cond (#f 5) (#t #f) (#t #\U0007AAE1) (else #f))))
                      (#f #\U000BD710)
                      (else
                       (cond
                         ((cond
                            (3 #t)
                            (#t #\鬘)
                            (#f -4)
                            (#f #\㯃)
                            (#f #t)
                            (#\U000EA05A #t)
                            (#t #\U0006A343)
                            (#f #\U0009F78F)
                            (-1 #\U00067396)
                            (#f #f)
                            (#t -5)
                            (else #\U000E99B4))
                          (cond (#f #\ླ) (0 #\ⱗ) (#t 4) (else #f)))
                         (#f -8)
                         (else -4))))
                    #t
                    #f))
               ((if (zero? #f) #f #t) #\ႊ)
               (#t #f)
               (else #f))
             (integer? 2))
            (else (integer? 64)))
          (let ((z0 #t)) (cond (else 0))))
         ((let ((s1 #\U000458A9)) (zero? #f)) #t)
         ((cond
            ((if #t #t #\U000C66F9) #f)
            (#t #t)
            (#f
             (if #\U00059116
                 (cond
                   ((cond
                      (#\U000CDDB0
                       (cond
                         (-4 128)
                         (#\桅 #\憤)
                         (#t #f)
                         (#f -2)
                         (#t #f)
                         (#f #f)
                         (#t #\䦦)
                         (-1 #f)
                         (#\U0007D628 -4)
                         (#t #\U000412EE)
                         (#\壃 5)
                         (#t #\U0006B96E)
                         (else #t)))
                      (#t 0)
                      (#t (char->integer #\U000316E9))
                      (33 -3)
                      (else -16))
                    17)
                   (1 -3)
                   ((abs
                     (cond
                       (#f -4)
                       (#\U000C1DE7 -2)
                       (-2 #t)
                       (#t -4)
                       (#\雊 4)
                       (#t #\U0006877B)
                       (#\噈 9)
                       (#\U000314DE -8)
                       (1 -4)
                       (#f #\U00079C42)
                       (#t #f)
                       (#\U0005961E #f)
                       (#t #\U00063324)
                       (0 #\痡)
                       (else #f)))
                    #t)
                   (5 (boolean? (cond (#\U000ED830 -8) (#f #t) (else #\U000AF330))))
                   ((if (- -1)
                        #t
                        (cond
                          (#f -5)
                          (#t -4)
                          (#\⇭ #f)
                          (#t #\霰)
                          (3 #t)
                          (3 #t)
                          (-1 -6)
                          (#t -1)
                          (#t #f)
                          (#t #t)
                          (#f 5)
                          (-8 4)
                          (else #\U00058CAD)))
                    #\U0005526A)
                   (#t (add1 #t))
                   ((boolean? (sub1 #\痊)) (if 4 -4 #f))
                   (else
                    (cond
                      (-3 #\U000AD054)
                      ((char->integer #\ܰ) #\⽖)
                      ((cond
                         (#\᯲ #f)
                         (#t #f)
                         (#t #\U0002D4DA)
                         (#t -4)
                         (9 #t)
                         (2 #f)
                         (#\⏫ 1)
                         (#\뷶 #\U0009C26D)
                         (else -7))
                       #f)
                      ((cond (else 2)) (if -3 8 #t))
                      ((char->integer #\ᒶ) (integer? #t))
                      (#f #t)
                      (else #\Ⲡ))))
                 #t))
            (#\쿰 (if #t (sub1 #f) 1))
            ((abs 4) (if #\U00054AFC #f #t))
            (else (sub1 2)))
          #t)
         (else -2))
       (cond (else (if (boolean? 3) 3 (char? #f)))))
      (-1 -3)
      ((char? (sub1 #t)) #t)
      ((if (cond (#t (char->integer #f)) (else (let ((b0 #\U00046EEE)) #t)))
           #f
           #t)
       #t)
      (#t (if #\룆 -17 (sub1 (let ((z2 #t)) #f))))
      ((let ((q2 #f)) (sub1 q2)) (let ((a2 #\軡)) a2))
      ((boolean? (zero? #f))
       (char?
        (if -2
            (add1 (if (if #\뿴 #f (- (cond (#t #t) (2 -2) (else -1)))) #\襗 #f))
            #t)))
      ((boolean? (abs #t)) #\U00033F28)
      ((let ((u0 #\U0007C613))
         (cond
           ((cond (#\U0004D8D5 #\伃) (#f #f) (u0 1) (4 u0) (#f u0) (else 32)) u0)
           ((let ((h1 #f)) -1) #t)
           (else #t)))
       (cond
         ((cond (else (if #f -5 #\㳳))) #\䫼)
         ((if (zero? -2) #\U000E9D50 (abs -1)) -1)
         (else #\삽)))
      (#t #t)
      ((if (if (let ((s1 -2)) s1) #\휮 #t) #\U000B5762 -4) #\鼦)
      (else (if (let ((p0 -3)) #\㈾) (abs (if #t #f #f)) -65)))
    -4
    1
    #\퀞
    (let ((m1
           (cond
             (#\U000E6895 #\編)
             (#\洞 (integer->char (char->integer #\舾)))
             (16 4)
             (#t
              (cond
                (#\U00095A70
                 (char?
                  (cond
                    (#t (if (integer->char -8) #t (if #f #t #f)))
                    (else (integer->char #t)))))
                (else -3)))
             ((let ((g2
                     (cond
                       (#t
                        (if #t
                            #\급
                            (cond
                              (#t
                               (if (integer->char #f)
                                   #f
                                   (cond (#\U0009D987 #f) (else #t))))
                              (#f #t)
                              ((cond
                                 ((if #\U000EC795 #t 2) 0)
                                 (#t (if -3 #t #\졑))
                                 ((char? #\꒛)
                                  (cond
                                    (#t #\U0004DBD2)
                                    (#f #f)
                                    (4 5)
                                    (-2 #\媯)
                                    (3 #\丹)
                                    (#t #\䁩)
                                    (#\仺 -3)
                                    (#t #f)
                                    (-3 #f)
                                    (-3 #f)
                                    (-4 #t)
                                    (#f #t)
                                    (-2 #\준)
                                    (#\U0005C069 #t)
                                    (#t #\U000AED7A)
                                    (#f #f)
                                    (5 #t)
                                    (else 14)))
                                 ((abs -1) #\奵)
                                 ((if #f #\ꖀ #t) #f)
                                 ((if #t #\U000707ED #t) (boolean? #f))
                                 (else #\uE1B6))
                               (if #f (cond (#\U000AC1CA #f) (else -5)) #t))
                              ((if (if #t #f 4) #\U001016DA (if #f #\䃘 #t))
                               (if #t #f (if #f #\☣ #f)))
                              (#f (if 9 (if #t #f #t) 3))
                              ((add1 (zero? #\U000FA319)) #\U00100751)
                              ((cond (else (if #t #\U00016E08 #\遇))) #\U000E9354)
                              (#t (char? (char->integer 1)))
                              (else #\U00102C22))))
                       (#\仟 #t)
                       (#t #f)
                       (#t -6)
                       (#f #\铥)
                       (#t #f)
                       (-64 #t)
                       (else
                        (cond
                          (#\螐 #f)
                          ((if (cond (else 1)) #t (if #f (integer->char #\𐢕) #f))
                           #\̸)
                          (-2
                           (if (cond
                                 ((if #f #f #f)
                                  (cond (#f #t) (#f #\졼) (#\熛 #f) (else #\啻)))
                                 (#\U0003515B
                                  (cond
                                    (#f 2)
                                    (#\U000A4D30 #f)
                                    (-1 #f)
                                    (else #\鵮)))
                                 (else (char? #\暲)))
                               (sub1 (if #t #f -18))
                               (if (zero? #\U0009CF10)
                                   #\ㇷ
                                   (cond (#f #f) (#t -1) (0 -36) (else #t)))))
                          (#t #f)
                          ((add1
                            (if #f #t (cond (#f 4) (-2 #t) (2 #\㏒) (else -1))))
                           (if #\U00068312
                               #\U000A57BF
                               (if (if #\U00103A28 #t #t)
                                   (if #\U0003194D -7 #f)
                                   #\쉗)))
                          (else -3))))))
                #t)
              -9)
             (#\賒 -2)
             (-2 (- (cond (else -8))))
             ((cond
                (#t (cond (-10 #t) (-1 #\U0006EF96) (else #\㔮)))
                (#f (let ((y1 #f)) #t))
                (else (let ((v2 #t)) #t)))
              #t)
             (#f
              (cond
                (#t #t)
                ((cond
                   (-9 #f)
                   (#f #f)
                   (#f
                    (cond
                      ((cond
                         ((abs -5)
                          (if (cond
                                (#\U000C0E69 #\U000B24E6)
                                (1 #\U000790D9)
                                (-7 2)
                                (else #\䯃))
                              #t
                              (cond (else #\U000CCA46))))
                         (2 #f)
                         (#t -1)
                         (else #t))
                       (cond
                         (#t #t)
                         ((cond (#t #f) (else -1))
                          (integer? (cond (#t #f) (else -9))))
                         (#t
                          (cond
                            (#\U0008ED68 5)
                            ((if #\ꙛ #\ඥ #\U0001AF0A) #f)
                            (else #f)))
                         (#f #t)
                         (#f #\⒏)
                         ((if #t #\亼 #f) (add1 #f))
                         ((zero? (cond (#t 1) (else #f))) #f)
                         (9 #\U000DC0A2)
                         ((sub1 #f) (if -4 #t (if #f 4 #\U000D0216)))
                         ((if #\蓕 2 #\U0004456C) #\U00037927)
                         (else #f)))
                      (#f 2)
                      ((cond
                         ((boolean? (add1 #\隤)) #f)
                         ((cond
                            (#t (boolean? #\扇))
                            ((if #f #t -2) (cond (else 33)))
                            ((char->integer -3) #\U000F12D6)
                            (#t #f)
                            (33 #\U000F478C)
                            (else 3))
                          (cond
                            (#f -1)
                            (#\U000317C5 #\蓾)
                            (#f #t)
                            (#\䂧 (boolean? -2))
                            ((integer->char #\膚) (add1 #t))
                            (#\걜 #\懾)
                            (#\㙚 (- #\U0004ECD6))
                            (3 (if #\ꢓ #t #t))
                            ((cond
                               (#f -5)
                               (#t #t)
                               (#t #\ૐ)
                               (#\U00107C9D #\⎾)
                               (else #\⮬))
                             (if -21 -2 #\U000B1602))
                            ((abs #f) #t)
                            (#t (- 2))
                            (#f (char->integer #t))
                            (else
                             (cond
                               (#t #\芭)
                               (-6 #f)
                               (#\U00046A40 #t)
                               (#\U0005B225 #f)
                               (#f #t)
                               (else #f)))))
                         (4 (if (cond (else #f)) (zero? #f) (- #f)))
                         ((if #f #\U0001FD17 #f) #\헟)
                         (else (char->integer (char->integer #\u1C85))))
                       (cond
                         (2 (- #f))
                         (#t
                          (cond
                            (#f 5)
                            ((boolean? #f)
                             (cond
                               (#\퓡 #\u0E67)
                               (#t #\U00093F77)
                               (else #\U000F87F2)))
                            (#t #t)
                            ((if #t #\釲 #t) #t)
                            (#f (cond (4 #t) (else #t)))
                            (-4 #\叿)
                            (else (if #f 1 4))))
                         ((if (cond (-2 #t) (#\U00087F19 -5) (else #\U00063AC1))
                              #\U00058FFA
                              (char? #t))
                          (if #f #t 9))
                         (else (integer->char (if #\ḕ #\U000943C1 #\U000DB310)))))
                      ((if #f (cond (else #f)) #f) #f)
                      ((if #\U00102267
                           #\瑩
                           (if (zero? #\U000D8072) (char->integer #t) #f))
                       2)
                      (#t #f)
                      (#t #t)
                      ((char->integer #t) (sub1 -1))
                      (-2 (if (- #\츁) #f 0))
                      (else #\蚀)))
                   (#t #\䍳)
                   (#f #f)
                   (#f #\u2FE0)
                   (#\َ #t)
                   (1 #f)
                   (#f #t)
                   (#t #f)
                   (-17 -2)
                   (#f #t)
                   (#t #f)
                   (else #t))
                 (if #f 4 -1))
                ((let ((p2 7)) p2) #f)
                (#\跛 (if #\ᗤ #t #t))
                (7 (if #\U0006E434 2 #f))
                ((integer? #\U0003A5E4) (char->integer #f))
                ((cond
                   (#\ඉ #t)
                   (#t #f)
                   (32 #t)
                   (#t -1)
                   ((sub1 6) #t)
                   (else #\U0003AC2A))
                 #f)
                (#f (cond (else #t)))
                (1 #t)
                ((cond
                   (1 #f)
                   (#f #f)
                   (#t -32)
                   (#t 32)
                   (#f #f)
                   (#f (cond (else #\U000B95D9)))
                   (#\U00082415 #\䗴)
                   (#t #\ኛ)
                   (else
                    (cond
                      ((boolean? #t) #f)
                      (#\劋 #t)
                      ((abs (boolean? #f)) -1)
                      (-3 #t)
                      (#t (if (if #\䦻 (abs 3) -2) (if #f 4 #t) 1))
                      (else (if (if #f 2 #\U000FC220) #\U000D5CD5 #t)))))
                 (integer? #f))
                (#f #\U0008DB35)
                (#\嚱 (cond (-1 #\𪂍) (#t #f) (#f #t) (else -2)))
                ((if 2 #\U0004677A 2) #t)
                (else #t)))
             ((char? #f) #t)
             (#\U0001E614 4)
             (#f #t)
             (#f #t)
             (else (zero? #\U000DDC60)))))
      1)
    (cond
      ((if #t
           #\U00036F79
           (cond
             ((integer->char #\U0004EAD9) #\ᇪ)
             (#t #f)
             ((if #t (cond (else #f)) #t)
              (cond
                (-2 (if #\뮱 (if 1 #\⠗ #\u0BAB) #f))
                (#f #f)
                (#t #t)
                (1 #t)
                (2 #f)
                (-2 #f)
                (5 #f)
                (9 (if #t #\U00081237 #f))
                (#t #\㽬)
                (#t -9)
                (else #t)))
             (#f (cond (-2 #\ꕔ) (else -2)))
             ((let ((k0 #t)) 4) (integer? #f))
             (#f (let ((c2 #f)) #f))
             (#t (let ((q0 #t)) #\硟))
             ((cond (else -2)) (let ((v2 #\䐱)) #\U000FE34E))
             (-4 -4)
             ((if #\U0006D344 #f -1) #f)
             ((add1 4) -4)
             ((cond
                ((integer->char #f)
                 (cond
                   (#\U0002C896 #f)
                   ((if #\醋 #f #t) (sub1 (if 2 #f #f)))
                   ((if #f #\U000D1188 (zero? #t)) #f)
                   (#t (cond (else (if #t -4 #\ꖛ))))
                   (#\U000DC2D4 #f)
                   ((if #f #t #\U00048035) #f)
                   (else #t)))
                ((- (integer? (if #t #t #f))) #\㮊)
                (#t -3)
                (1
                 (if (cond
                       ((zero? #f) #t)
                       (-1 (if #t #t #t))
                       (0 (if #\璤 #\맨 #t))
                       (else (integer? #\U000A2837)))
                     (cond
                       ((integer? -4) #\u1ADE)
                       (#t (cond (else 3)))
                       ((cond
                          (#t #t)
                          (-2 #t)
                          (4 #\꺆)
                          (#t 7)
                          (#t #t)
                          (#t #f)
                          (#\U #\쏃)
                          (#\U0008AFF2 #f)
                          (#f #t)
                          (1 #\U00078682)
                          (#t #t)
                          (7 #\槐)
                          (else 2))
                        (if #t #\U000A468E #f))
                       ((cond
                          (4 #f)
                          (-2 #\䏒)
                          (#t #f)
                          (#\U0003C41B #t)
                          (#\츊 #t)
                          (#f #f)
                          (#\넔 #t)
                          (#f #f)
                          (#t #\㪃)
                          (-6 -1)
                          (#t #f)
                          (#\ꐏ 2)
                          (#t #\믩)
                          (else #t))
                        (cond
                          (-2 1)
                          (#f -8)
                          (#f #t)
                          (#f #\U0009F227)
                          (#\㸵 #f)
                          (#f #\U00051603)
                          (-1 #\嗆)
                          (1 #t)
                          (#t #t)
                          (else #\u2C2F)))
                       (else (cond (#t #t) (2 5) (else -1))))
                     (cond
                       (#\劬 (sub1 #f))
                       ((zero? -2) #f)
                       (#f (if #f 2 #t))
                       ((cond (#f -1) (#t #\喩) (-2 #f) (#f #f) (else #\汕)) #\税)
                       ((integer? #t) #f)
                       ((- #\퐸) 2)
                       (#f (if #t #f 9))
                       ((if #f 2 #\⏤) (sub1 2))
                       (else #\ְ))))
                (else (if #\穊 (if (zero? 8) (if #f #f #t) (if #f #t #\屝)) 1)))
              #t)
             ((if #\膅 #t #\뢨) 11)
             (-2 #t)
             (else (abs #f))))
       #t)
      (#\U000BC7A3 #t)
      ((cond
         (#\U00040D72 #f)
         ((integer? #\U000D370B) #f)
         ((cond
            (#\璂 (sub1 13))
            (#t (if #f -2 #f))
            (#t (if #f #t #\嘥))
            (-1 (integer? (char->integer #\䫯)))
            ((if #f #t #f) (if (cond (else #t)) 16 -6))
            (6 (if #\U000D9601 #t (char? #t)))
            (#\釙 3)
            ((if -65 #f #t)
             (cond
               (#f #t)
               (#\U000B4548
                (sub1
                 (cond
                   (else
                    (cond
                      ((cond (else #\U00046E84)) #t)
                      (#\窳 -1)
                      ((cond
                         (#f #f)
                         (#t #\咉)
                         (#\𠿑 #f)
                         (1 #t)
                         (-4 #f)
                         (#\U0001E70C #t)
                         (0 #t)
                         (else #\U00068478))
                       (if #f -2 -9))
                      ((- #f) 6)
                      (#f #f)
                      ((cond (#\U000E60E8 #t) (#t #t) (#\ꍱ #\U000536BD) (else 3)) #f)
                      (else #\얰))))))
               (1
                (boolean?
                 (cond
                   ((cond
                      (0 #f)
                      (#\䐙 #f)
                      ((char? #t) #t)
                      (else (if #\U000C2F0A #t #t)))
                    #f)
                   ((integer? (if #t #\U000E0C0A #\霈)) #f)
                   (#f
                    (if (if #f -32 #f)
                        (cond
                          (#f -2)
                          (#t #\ꈨ)
                          (#t 1)
                          (#\U000B79AA #t)
                          (#\ꉌ #\U0005B9B9)
                          (-3 #t)
                          (#\䬙 #\U0004534A)
                          (3 #\歼)
                          (-2 #\䰞)
                          (#\젏 5)
                          (#\U0007625B #\繃)
                          (#t #t)
                          (#\U0009E957 #f)
                          (#\U0001E1BE #\癭)
                          (#\U0006A9E1 #t)
                          (#f #t)
                          (#t #\袯)
                          (#t -2)
                          (#f #t)
                          (else #t))
                        #f))
                   (#\땩 (abs -1))
                   ((cond (else #f))
                    (boolean?
                     (cond
                       (#t #t)
                       (#\U00050533 -8)
                       (#t #t)
                       (#\U0006D82C #t)
                       (#f #f)
                       (#f #\莫)
                       (#t #t)
                       (#f #f)
                       (2 #f)
                       (#f #\䱅)
                       (#f #t)
                       (#\赻 #\U0001DFC2)
                       (11 #f)
                       (2 #t)
                       (else -3))))
                   (#f
                    (if 2
                        (cond
                          (#t #f)
                          (#f #t)
                          (#t #f)
                          (#\譿 #\U000E63E5)
                          (#f #f)
                          (#f #\u05F6)
                          (#\U0008271D -6)
                          (#f #f)
                          (2 #f)
                          (#f 4)
                          (-4 #\릵)
                          (#f #t)
                          (-7 #t)
                          (#f #f)
                          (1 #\U000904E7)
                          (#t #t)
                          (#f -3)
                          (#t #f)
                          (#f #f)
                          (#t #f)
                          (else #\U00015695))
                        #\U00011D2E))
                   ((if #t #t (if #t #f #t)) #\U000E9C43)
                   (#t #t)
                   (else #\U0001743C))))
               (else 10)))
            ((if #\𡎍 #\陵 #f) (let ((d1 #t)) #f))
            ((if #f #\鑯 #t) #f)
            (else
             (if (if (cond
                       (#t #\졻)
                       ((if -5 4 4)
                        (cond
                          (-1 #f)
                          (#t #t)
                          (#\U000378A6 #t)
                          (#\荼 #\U0008F097)
                          (#f #t)
                          (else #\U000386C4)))
                       (else #f))
                     #f
                     (cond
                       (#f 2)
                       ((if #f 3 #t) (if #f #\U0003A029 #f))
                       ((if -1 #\U000B5DFB #\U00076731) (if -2 #f 4))
                       (-4 #f)
                       (#\U00054A46 (if #f #t -64))
                       (#f #\˕)
                       ((if #t #\U000ACA91 #t) (add1 #f))
                       (#t (if #f #t #\坁))
                       ((if -3 #\히 #t) #t)
                       (-3 #f)
                       ((abs #f) #f)
                       ((if #\𤻧 #t #t) #t)
                       (#f (- #t))
                       (#\U000E12E9 #\U000D8977)
                       (#f (char? #t))
                       (else #\ଇ)))
                 #\U000ABA4D
                 #f)))
          #f)
         ((let ((x0
                 (cond
                   (2 #f)
                   (#f 3)
                   (#t 2)
                   (#\U00057FA8 #\𦲾)
                   (#f 2)
                   (-3 #f)
                   (else 3))))
            (cond (else #\U00032E2C)))
          (cond (else #\u0E7E)))
         (#t #t)
         ((let ((f1 #f)) 2) #f)
         (#t (boolean? (let ((v2 #t)) #f)))
         ((cond
            ((cond
               (#\崘 #\揦)
               (#f -33)
               ((if (zero? #t) #f #t) #t)
               ((if #\U00097783 (boolean? #\U000AF68F) -4) #f)
               (else #f))
             #\U00043783)
            ((integer?
              (cond
                ((abs
                  (cond
                    (#t #\旖)
                    (#f #f)
                    (#\U00068ED8 -2)
                    (0 -5)
                    (0 #\U00051991)
                    (#t #\ዿ)
                    (-2 #f)
                    (else -3)))
                 (if (cond (else #t)) #f #f))
                ((sub1 #\U0004E979)
                 (cond (2 (if #t -3 #f)) (#\𨈇 (if #f #\㼱 #f)) (1 -4) (else -2)))
                (#\U000FC7D3
                 (cond
                   ((if #f -2 #t) (if #t #f #t))
                   ((- 4) (- #f))
                   (#\鏡 #t)
                   (#\꣖ #f)
                   (#f 9)
                   (#f (if 32 #f #f))
                   (else #f)))
                (-2 (if #\U0005F3EA #f 2))
                (1 -3)
                (else #f)))
             4)
            (#\U0009C8F0 (- 0))
            ((let ((l1 #t)) -4) #f)
            ((cond
               (#\猢 #t)
               (1 #\ʗ)
               (#f #\U000B1075)
               (6 #f)
               (6 #f)
               (else #\U00048E6E))
             #f)
            (#\U00046CC8 5)
            (#f
             (cond
               (#\㡣 #\U000D5F2B)
               (#f (char? #f))
               (#t #f)
               (#t #t)
               (#f (integer->char -4))
               (else #\U000C5969)))
            (#t (if 2 #f #t))
            (#\U0009053F #\蹚)
            ((integer->char #f) (let ((m1 -4)) #t))
            (#t #t)
            ((add1 #\畯) 2)
            ((add1 #\ᇥ) #f)
            (0 #f)
            (else (if #\U000EF296 #\U0006BD5A #\U00061749)))
          (if #\绳 (let ((x1 #\湏)) 2) 2))
         (else (cond (-1 #\U0007F0E1) (else 2))))
       (let ((j1 #t))
         (cond
           (#\U000382E6 (char? #\Ὲ))
           ((let ((t2 j1)) #\U000C79FC) (if -32 #f 1))
           ((cond (2 #\U0003BD4C) (#\筎 j1) (j1 -2) (j1 #\蜌) (9 2) (else j1))
            (cond (else j1)))
           (j1 6)
           (#t 2)
           (else (if #t j1 #t)))))
      (#f -16)
      ((if #t #t (let ((n1 (char->integer #\嶌))) 7)) #\䰝)
      (#\U00056753 -4)
      ((cond
         ((integer?
           (cond
             (#t
              (cond
                ((cond
                   (#t (if #\廳 #f #t))
                   ((if #f #\沭 #t) (cond (#f #f) (else #f)))
                   ((integer? #\U00031852) #\᭘)
                   ((cond (#t #f) (-2 1) (else #f)) (if -3 #f #t))
                   (else -1))
                 (if -3 (if #t #\兂 #\È) (if #\Չ #t #\礋)))
                (#t (if (if #\U000A4461 -16 #f) #\谽 #\륤))
                (else
                 (cond
                   ((zero? -3) #t)
                   ((cond
                      (#\旸 #\瞐)
                      (#f #f)
                      (0 #t)
                      (#\継 #t)
                      (-9 #t)
                      (#f 8)
                      (#f #f)
                      (#t #t)
                      (128 -4)
                      (#\쬕 #f)
                      (11 1)
                      (#t #t)
                      (#f #t)
                      (#f #f)
                      (#\U000CF024 #f)
                      (#t 1)
                      (else #\だ))
                    (cond
                      (#f 1)
                      (#t -4)
                      (#t 256)
                      (6 #\迾)
                      (-4 #\⅛)
                      (#\秫 -1)
                      (7 #f)
                      (#\U00057E3C -2)
                      (#\U000EBEA1 #f)
                      (#f #\U0007B818)
                      (#f #\飗)
                      (2 0)
                      (else #f)))
                   (-4 #\U000F53D0)
                   ((cond
                      (#\U00075C60 #\U000F52F2)
                      (#\U000CFA57 -2)
                      (#\U00044F58 #t)
                      (-1 2)
                      (#\Ρ #\ⅵ)
                      (#f #f)
                      (#\U0003DFFB 0)
                      (else -6))
                    -4)
                   (0 #t)
                   (#t #f)
                   (#f -32)
                   (else 8)))))
             (#\滟
              (cond
                (#f #\U000D0C3E)
                (-2 (integer? (if #t #\ᐼ -2)))
                (#t #f)
                (#\U00074536 (if #f #t #t))
                ((cond (5 (if -2 #\U000AC173 #f)) (else #t)) #t)
                (#t #f)
                (#f #t)
                ((if #\禯 #f -2) (if 3 -2 (add1 #\U00013E62)))
                (#\U000F4F32 (boolean? (if #f -4 #f)))
                (else #\ᐂ)))
             ((if #f 1 3)
              (cond
                (else
                 (zero?
                  (cond
                    (#t #f)
                    (#\U000300AA #f)
                    (#f 1)
                    (#\U000D008B #\U000181CA)
                    (3 #\䡃)
                    (#\U0008769C #t)
                    (else #\U0008E394))))))
             ((cond
                ((integer? (sub1 #\U000B0A19))
                 (if (if #\U00105DA4 #\U000AECC8 #\㖕)
                     #\u0CF3
                     (cond (#f -4) (4 #\U000620E9) (else 8))))
                (#f
                 (cond
                   ((sub1 #\尥) #t)
                   ((cond (#\U000E704B #f) (#t #f) (5 #f) (#f #\흢) (else #t)) #f)
                   ((zero? 2) (if #\碂 #f 10))
                   ((integer->char #f) 1)
                   (-17
                    (cond
                      (#\岻 #f)
                      (0 #t)
                      (#\䂤 #t)
                      (#t #\𪓼)
                      (#\U0008A613 #t)
                      (#t #t)
                      (#t #t)
                      (#\揗 #\u1CBC)
                      (#\ꛔ #\U0007F9ED)
                      (#f -5)
                      (-2 #\荤)
                      (#\U000B181F 2)
                      (#\罔 #t)
                      (6 #t)
                      (else #\墤)))
                   ((cond
                      (#t 3)
                      (#t #f)
                      (#t -8)
                      (-3 #\U0002BF02)
                      (#t #t)
                      (else #\軱))
                    #\迶)
                   (else (if #f #\ͯ #\ᷲ))))
                (else (if (if #t #f 1) (boolean? #t) #\谲)))
              #f)
             ((if #\鶷
                  #t
                  (cond
                    (#f
                     (cond
                       (#t -1)
                       (#t #t)
                       (#\U000A885E #f)
                       (#\䒱 #f)
                       (#t #t)
                       (#t #t)
                       (#t #\U001001B1)
                       (#t #\ƴ)
                       (0 -5)
                       (else #\U00043ADD)))
                    ((if #t -1 #t) #\樣)
                    (#f (if #t #\U00092620 #f))
                    ((if #\웑 #f #\橳) (if #f #t -5))
                    (#f -9)
                    (#f (if 16 1 #f))
                    (#\uE1E2 (if #f #t -1))
                    ((if #\U000A9D96 #f #f)
                     (cond
                       (#\uE220 #f)
                       (#\ꚨ 4)
                       (#f #f)
                       (-2 #\U000641EF)
                       (-1 #t)
                       (#f -17)
                       (#\U00059624 #t)
                       (#f 2)
                       (else -1)))
                    (else #f)))
              #\U000AA715)
             ((if (if #t
                      (cond
                        (-32 #\U000FE9D3)
                        (#\뷓 #t)
                        (#f #f)
                        (#\璬 -1)
                        (4 #\诗)
                        (else #\U00051613))
                      #t)
                  #t
                  #\U00070549)
              (integer->char (cond (#\U0004D219 (add1 #t)) (else #\U00089EEB))))
             (6 (integer? (sub1 (if -1 #f 5))))
             ((if 1 (add1 #t) #t)
              (cond
                (#f 1)
                ((if (cond
                       (-1 #\U000972CD)
                       (#t -6)
                       (-7 #\U0002D848)
                       (#\U001088F6 #\큫)
                       (#\𫟒 #f)
                       (#\䩓 #t)
                       (#f -4)
                       (else #t))
                     (cond (#t #f) (#f -3) (else #f))
                     9)
                 #\㛒)
                (else #t)))
             ((cond
                (#f #f)
                ((if #\U000D8EE7 #\U000F37C0 #\U000B3F51) #\U000E4B1C)
                ((zero? #\U000843D4) (zero? (cond (-4 #f) (else #t))))
                (#\抴 #\U00096D0C)
                (else #f))
              #t)
             (#t #f)
             ((if (if #t (if #\U000162A6 #f #f) (if #t #\𢼺 #t))
                  (if (sub1 #f) #f (if #t #t #t))
                  4)
              (integer? #t))
             (else #t)))
          2)
         ((cond
            ((cond
               (#\U000E4D44
                (cond
                  ((if 1 4 -1) 3)
                  (-2
                   (integer->char
                    (if (cond (#\惣 #t) (2 #t) (else 8))
                        1
                        (cond (#t #f) (#f #\U0005898C) (else #\괰)))))
                  (3
                   (cond
                     ((cond (else #t)) #\荝)
                     ((if (if #t #\U000DB440 #t) #f #\䓽) #t)
                     ((if #\ဣ #t (cond (#t #f) (#t 4) (#f #t) (else #t))) #t)
                     ((cond
                        ((if #f -2 #t) #f)
                        (-2 (cond (#\㵷 #t) (#t -7) (5 #f) (else -1)))
                        ((boolean? -5) (if 4 #f #\籭))
                        (-1 (if #\U0003ED81 #f #\궎))
                        (#f
                         (cond
                           (#t #\U00103B0A)
                           (#\U00052954 #t)
                           (#f -4)
                           (1 #\U0001EBCE)
                           (#\䠔 #\U000DB4FE)
                           (#f 5)
                           (#f #f)
                           (#t #t)
                           (9 #f)
                           (-1 #\U0009F491)
                           (#f #f)
                           (else -6)))
                        ((sub1 #\鈟) (cond (else 1)))
                        ((zero? #\U000B0462) (if 0 #\U00073A32 #t))
                        (else #f))
                      #f)
                     (#f #\U0007136B)
                     (else (sub1 #\U000BCE14))))
                  (#f -5)
                  (#\U000DEDC5
                   (if 2
                       (cond
                         (#\U000E1FB8 #\䂇)
                         (-11 (if #t #\岅 #\U000B14A3))
                         (2 (integer->char 6))
                         ((integer? #f) (if #t 1 #t))
                         (#f #\U00039A67)
                         (#f (if #f -4 -1))
                         (#t (integer->char #f))
                         ((zero? 1) (cond (else #f)))
                         (#\U000E38F9 (integer? #\䷕))
                         ((zero? #\甁) (char? #t))
                         ((cond (#f #f) (else #f)) #\U000C1B8A)
                         (#t #\U0006E85E)
                         (#f 4)
                         (#t
                          (cond
                            (-4 -1)
                            (-3 -4)
                            (#t #\핋)
                            (-2 #t)
                            (#\U0005C268 2)
                            (else #f)))
                         ((boolean? #t) #\U000D2CFC)
                         ((char? #\U000820BB) #t)
                         ((cond
                            (0 #t)
                            (#f -1)
                            (#\闪 #t)
                            (1 #\U000BB827)
                            (-4 #t)
                            (#f #f)
                            (#f #\恽)
                            (#\U0005E733 #f)
                            (else #f))
                          #f)
                         ((- #f) #t)
                         (#f #f)
                         ((if #f #t 16)
                          (cond
                            (#t #t)
                            (#t #\堕)
                            (1 #t)
                            (#\U000E3C18 1)
                            (#\U000A99E4 #\U0008209F)
                            (else #f)))
                         (#\犿 (if #f #\U000A1F7F #\U0002BE09))
                         (#\Ą #t)
                         (#\졁 (if -1 -1 #f))
                         (#t #\𣦭)
                         ((cond (#t -32) (-2 4) (#\U000D4FB8 #\䑚) (else #f)) -8)
                         (-9 1)
                         (else -2))
                       #\U00031DD2))
                  (#\U0006E753 #\uF6AC)
                  (2 #f)
                  (else
                   (if (cond (#f (abs #f)) (#t #t) (#f #\鸍) (else (integer? #t)))
                       (if (if 1 #\⺳ #f) -1 #t)
                       #f))))
               (3 #\씭)
               (#f #\Ꚙ)
               (else #\U0007FA31))
             (let ((r0 #f)) #t))
            ((cond
               (4 #f)
               (1 #\U00030C89)
               (17 #\U000AF746)
               (#t
                (cond
                  ((cond (else #\U0008D8C7)) #\U0001C92C)
                  ((add1 (cond (else (abs 10))))
                   (cond
                     ((if 2 (integer? 1) #\U0007758C)
                      (if (cond (#\ᒐ #f) (else #f)) (if #f #\ᤦ #\╗) #\U0009D500))
                     (#\∌ (integer? (char->integer #f)))
                     (2 #t)
                     (else (if 2 #t #t))))
                  (#\䛦 (if -4 (cond (21 4) (else #t)) (add1 (char? #t))))
                  ((if #t
                       #f
                       (cond
                         ((zero? #t) #f)
                         ((cond (else #t)) #f)
                         (#\U0009D6DF #f)
                         ((cond
                            (#\铈 #\U000F8C33)
                            (#t #f)
                            (#f #t)
                            (#\➜ #t)
                            (4 #f)
                            (5 #\uE1FC)
                            (#f #t)
                            (#f #t)
                            (else #t))
                          #f)
                         (#\䌼 (if #t #f #t))
                         (#\U000D7088 #f)
                         (4 (char? #t))
                         (else (- #t))))
                   (- (add1 #f)))
                  ((cond (-5 #t) (else #t)) -5)
                  (#\竭 #t)
                  ((add1 #f) #\U00057AF7)
                  ((zero? #f) 0)
                  (else #f)))
               (#t #t)
               (else -4))
             (if (if (sub1 #t)
                     (cond
                       (#\搞 #f)
                       (#t
                        (if #t
                            (cond
                              (#\䢵 #\U000A2541)
                              (#\臝 -2)
                              (#\𨾥 #f)
                              (#\U000EFDE6 #f)
                              (#t -4)
                              (2 #f)
                              (#f #t)
                              (#t 1)
                              (#t #f)
                              (else #f))
                            6))
                       (1 (if #t (if 0 #f #f) #\顕))
                       (else 3))
                     (if (abs 10) (if #f #t #f) (boolean? #f)))
                 #t
                 #f))
            (3 (integer? #f))
            (#f #\㤱)
            ((zero? #\硳) #t)
            (1 (if (if #\罝 #f #f) #\U0009314D -10))
            ((if #\U0003DEEF (if #t 4 #\舚) (- #t)) 2)
            ((integer? #f) #\U000598E1)
            (#f 2)
            ((if #f #f #\鋿) (let ((c1 #\U000EC2C4)) #f))
            (else (zero? 3)))
          (integer? 4))
         (#f #f)
         ((let ((a1 (let ((v2 #f)) #f))) (cond (else #f)))
          (if #t
              (cond
                (0 2)
                (#\ᾍ (cond (else #\హ)))
                (#\U000DB309 2)
                (#f (char->integer #f))
                (#\U000CAE7D #t)
                (2 #\⎑)
                (2 3)
                (#f #\ꔳ)
                (-4 -3)
                (16 4)
                ((char->integer #f) #\𨦣)
                (#t 4)
                (#\U0003041D #f)
                (1 #t)
                (-17 -4)
                (#\⩞ #t)
                (#t #\U00054A28)
                (1 #f)
                (#t -2)
                (#f #\戇)
                (#\淞 #\ᄰ)
                (#f (if -5 #f #f))
                ((boolean?
                  (cond
                    ((if (char->integer #t) (- #t) #f) (abs #t))
                    (#t
                     (cond
                       (2 #t)
                       (#\甡 #\U0008E1B3)
                       ((if #\U000DE8EA #\uEB4C #t) #t)
                       (else (cond (#\U00096740 #\U000AF394) (else #\U000FD653)))))
                    ((char->integer #f) #\U000D8A70)
                    ((cond
                       (#\讇
                        (cond
                          (4 #t)
                          (#t #f)
                          (#f #\U00100F5F)
                          (#t #f)
                          (0 0)
                          (#f #f)
                          (else #t)))
                       (else #t))
                     #f)
                    (else #\U000ECA3C)))
                 #t)
                (#f #t)
                (#t #\ᤉ)
                (#\U000D672C #f)
                (#f 0)
                (else #t))
              #f))
         (#t -2)
         (else
          (char?
           (integer->char
            (cond
              ((cond
                 (#t (if 2 #\ꑀ #f))
                 ((cond
                    (#f (cond (#\U0008EAB0 #t) (-2 #f) (#\沔 #t) (else #\ꇉ)))
                    (#\U00073D4F (cond (else #\U000AAF9A)))
                    (#t (if #f #f #f))
                    ((integer->char 5) #\맍)
                    ((cond
                       (#\쑊 #t)
                       (#\U000EB6B3 1)
                       (#f -2)
                       (#\U001019A4 #\浫)
                       (#f #t)
                       (4 #f)
                       (#f #\▛)
                       (-3 #\뵽)
                       (#t 2)
                       (#t #f)
                       (else 8))
                     #t)
                    (else
                     (cond (#t #t) (#\U00054E42 -5) (#f #f) (#t #f) (else #\讈))))
                  (cond
                    (#\U000D17B4 #t)
                    ((cond (#f #f) (else #t)) (if #t #\㨃 #f))
                    ((cond
                       (0 -3)
                       (#t 0)
                       (-1 #f)
                       (#\U000EB384 #f)
                       (#\U000731C1 #t)
                       (else #\䱟))
                     (cond
                       (#f #t)
                       (#t 8)
                       (#t #\න)
                       (#t #\U000AC414)
                       (#t #\U000A0BC4)
                       (#f #t)
                       (2 #\U00083154)
                       (#t #t)
                       (-4 #\╽)
                       (-1 #\U00072882)
                       (0 #t)
                       (#f -1)
                       (#t #t)
                       (#f #\U000EA472)
                       (else -4)))
                    ((cond
                       (#\ȹ #f)
                       (#\U0005EDC6 #\傱)
                       (-2 -3)
                       (#t #\눆)
                       (-4 #\䪘)
                       (#t #f)
                       (else #f))
                     #f)
                    ((cond (-2 #f) (3 #t) (4 1) (2 #\U0010C8E8) (#t #f) (else #t))
                     (cond
                       (#t 0)
                       (#\큝 #t)
                       (#t -1)
                       (#f #t)
                       (#\U00065AF4 #f)
                       (#f #t)
                       (#t #f)
                       (3 #t)
                       (#t 2)
                       (else #t)))
                    (#\U0002F307 (if #\ᶢ #\췥 1))
                    (#f -3)
                    (else #f)))
                 (#f (add1 -4))
                 (-2 -3)
                 (#\疏 -1)
                 (#t (integer->char #f))
                 (-4 (abs #f))
                 (#f (- (cond (-3 -1) (2 #f) (-6 #\飂) (-3 #f) (#\㎻ #t) (else -1))))
                 (#\U0003834A (cond (else (zero? #t))))
                 (#f (if #t #\〉 #f))
                 ((if -1
                      (abs -2)
                      (cond
                        (#\辭 -3)
                        (#f 1)
                        (#t #t)
                        (-7 -1)
                        (#t #f)
                        (#\𝕰 #t)
                        (else #t)))
                  #f)
                 (#f (if #f #\U000CBF54 #\U0009C393))
                 ((if (if #\ꦪ #\ⴃ #t) (if #f -2 #t) 34) (integer->char -5))
                 (0 #t)
                 (#\U000AAB85 -3)
                 (#t (if 2 (if #t 6 #f) -2))
                 ((integer? #f)
                  (cond
                    ((cond (#\䥨 #\岪) (#t #\U000EE17E) (#f #t) (#\흴 #\㩜) (else #f))
                     #t)
                    ((cond (else #\婈)) (if #f #\䓯 #\U000E67F4))
                    ((if #f -16 #t) #t)
                    (-3 #t)
                    (#\U00012F43 (char->integer #f))
                    (#f #\┳)
                    (else 1)))
                 ((cond
                    ((cond
                       (#t #t)
                       (#t #t)
                       (#f 4)
                       (#t 1)
                       (3 #\U000C5D7F)
                       (1 2)
                       (#t #t)
                       (#f #\U0009357C)
                       (#t #t)
                       (#f #\u31BD)
                       (else #\蘚))
                     1)
                    (else #t))
                  4)
                 ((zero? #t) #t)
                 (#f #t)
                 ((if #\U000D5763 #f 1) 2)
                 (#t #f)
                 (else 2))
               (cond
                 (#f (if #t #\U0009398B (if #\U000B9276 #t #\U000CCF87)))
                 (#t 2)
                 (#f #f)
                 ((add1 #\𐐖) #\ฏ)
                 (#t #f)
                 ((integer? (zero? #f))
                  (if #f #\U00076089 (cond (#\鎜 -4) (4 #t) (else #f))))
                 ((boolean? #t) -2)
                 (else #\U00098892)))
              ((zero? #\𣞱) #\U000D26F9)
              (#\ᛣ 0)
              (-2 #\쉦)
              (#f (if #f #t 2))
              ((if #f
                   (if 3 (cond (#f #f) (#f 2) (#t #t) (#f #t) (4 2) (else #t)) #f)
                   2)
               (cond
                 (#t
                  (cond
                    ((abs #f) #\U0007B5A6)
                    (#\U000C71D6 (cond (-1 #\߭) (#f -1) (else -5)))
                    (#\눥 (cond (-2 #t) (#t #f) (else #\鞞)))
                    ((cond
                       (#\㞪 #t)
                       (0 #f)
                       (-8 #f)
                       (-2 #\ῦ)
                       (-4 #\U000541F3)
                       (#\ᠣ #f)
                       (#f #\U00087E74)
                       (-36 #t)
                       (#f -9)
                       (-2 #f)
                       (#f 2)
                       (16 #t)
                       (else 9))
                     128)
                    (#\궙 (cond (else #f)))
                    (#f (cond (else #t)))
                    (else -2)))
                 ((if (abs #t) #t #t) #t)
                 ((cond
                    (0 -6)
                    (-3 -1)
                    ((zero? #\U00069E9E) (integer? #f))
                    (else 4))
                  #f)
                 (#\U000FF2AC #\堥)
                 ((cond ((if -1 #f #t) 3) (else (cond (#f -5) (else 1))))
                  (cond ((abs 2) 2) (else (- #t))))
                 ((if (if #t #\ꖾ #f)
                      (cond
                        (#t -33)
                        (#f #f)
                        (#t #\U00060FF3)
                        (#\U0002D750 1)
                        (-5 #t)
                        (#\U00047103 #t)
                        (#t #f)
                        (#f 3)
                        (#f #\U000A63CB)
                        (1 #\U00105AC9)
                        (else #\U000E1B4E))
                      #\U000F6095)
                  (sub1 #f))
                 ((if (if #t 17 #f) #f (char? -4)) #f)
                 ((cond
                    (-2 (if -3 #t 7))
                    (#t (cond (#t #t) (#t -2) (#t #t) (else #f)))
                    (else 1))
                  (cond
                    (-1
                     (cond
                       (#t #f)
                       (1 #f)
                       (#\ᑳ #f)
                       (#f #t)
                       (4 #f)
                       (#t #\뱗)
                       (else #\恉)))
                    (-2 #f)
                    (else (integer->char 0))))
                 (#\U000B9CEE (cond (else (if #\U0009801C #\푘 #t))))
                 (8 #t)
                 (else #t)))
              (-2 (boolean? -1))
              (else #\U000C63A4))))))
       (let ((i0
              (cond
                ((char->integer #t) (cond (-1 #t) (else #\U000E177A)))
                ((if #f #f #f) 3)
                ((let ((h2 2)) 1) #f)
                (else #\U000DBF85))))
         #f))
      ((char?
        (cond
          ((if #\㚊 -34 4) (if #t -1 #\䐌))
          (#\𤱩 #\⪆)
          ((if #t 9 #f) #t)
          (4 (let ((y0 1)) y0))
          ((cond
             (#t
              (if #t
                  -5
                  (zero?
                   (cond
                     (-2 (if -4 #f 2))
                     (#f 8)
                     (#t (if #f #t #f))
                     (#\U000DAD62 -2)
                     ((add1 #t) #\U000A30EB)
                     (else (cond (#f 4) (else #t)))))))
             (4 #t)
             ((cond (else -2)) #f)
             (#t 4)
             (-3 #t)
             (#\㠐 #t)
             (-2 #t)
             (#f #t)
             (else 4))
           1)
          ((if #t #t (char->integer #f)) (if #t #\U0004C160 #f))
          ((if #t #t -5) #\U000EFEE1)
          (else #f)))
       #t)
      ((let ((z0
              (char->integer
               (cond
                 (-1 #t)
                 (#t #f)
                 (#\U00098C91 #f)
                 (#\鷉 #t)
                 (2 #\U000D2365)
                 (66 #\胜)
                 (#\斖 #f)
                 (#f #t)
                 (-13 #f)
                 (else #t)))))
         (if (if #t #\중 #f) (zero? #t) #t))
       (char->integer (- 0)))
      (else #t))
    (let ((t1 #\佟)) #t)
    (let ((t1 (zero? #t))) t1)
    #\㟡
    (let ((a1 #\U000FB454)) (if #f #\䜣 3))
    (add1
     (cond
       ((integer->char
         (char?
          (if (cond
                (-4 #t)
                (#\熩 (cond (#f -1) ((if #t 2 -1) #f) (else 1)))
                ((abs (cond (else #\ꓓ))) (boolean? (if 16 #f 0)))
                (1 #f)
                (else
                 (cond
                   ((add1 #\U000E9483)
                    (cond (#f #t) (#t #\U000B8F86) (#t #\U000A5BED) (else #t)))
                   ((if #f #\u4DB7 #t) (abs #f))
                   ((char->integer #t) 1)
                   (#f #\U0004D380)
                   (#\U00043F26 #t)
                   (else #t))))
              #f
              #f)))
        #t)
       ((if #\থ -3 (cond ((if (integer? #\U0006538F) #f #f) #f) (else #t)))
        (if 17
            (cond
              (#t #t)
              (#\𥱢 #\u08D6)
              (#f #\ꉇ)
              (#f 3)
              (#\쒙 #f)
              (#\ⶼ 0)
              (4 -2)
              (4 -1)
              (#f 3)
              (#\U000A10A1 (sub1 #f))
              (#\踗 #\ꨪ)
              (#f #\U0010836B)
              (#\U0006C8F5
               (if (cond
                     ((cond
                        (else
                         (cond
                           (-8 -1)
                           (#t -4)
                           (#\𤙉 4)
                           (#t #\U000CF888)
                           (#t #t)
                           (else 8))))
                      #t)
                     (-1 #\U000D80E9)
                     (else -2))
                   (if #t (char? #t) #f)
                   #f))
              (else #t))
            #t))
       ((cond
          ((char->integer #\U0005CFF4)
           (cond
             (#t #f)
             (#t #\U000C59C9)
             (2 #\U000410DE)
             (-1 2)
             (#\U00037D7E #\Ⴜ)
             (#t #f)
             (#t 2)
             (else #t)))
          (else #\U00068EC5))
        #t)
       ((cond (else (if #\욕 #f 4))) #\U00058715)
       (#\씔 (if #\U000E6BAD (let ((g1 #f)) g1) -2))
       (else (if (if 5 #\竧 #\ᤈ) #f #t))))
    (cond (4 #f) (else #f))
    (let ((g2
           (cond
             (8 (integer? (add1 #t)))
             ((add1 (if #\U000C6194 #\狄 -2))
              (if (if #t -6 #f) (if #f #\U000A976D #\曗) (char->integer #f)))
             ((let ((m1 (cond (#\U00097977 #t) (#\碪 #f) (else 1)))) 3) #f)
             (#f #\U000A53EF)
             (else #\U000856D7))))
      #\U0009B7A9)
    (integer->char (let ((k1 #f)) (cond (else #\࿆))))
    (char->integer
     (cond
       ((integer->char -1) 2)
       ((- (if (char->integer -2) #t -2)) #f)
       ((cond (0 #f) (-2 #f) (else #\U00090875)) #t)
       (#t
        (cond
          ((if (if #f #t #\ជ) (if #\U00066753 #t #f) (if #\턂 #\ꊤ -1))
           #\U000D874E)
          (else (if #f (if #\ᮀ #\띒 #f) (if -16 #t #f)))))
       (-4 4)
       (5 #\䪭)
       (else #\큨)))
    #t
    (if #\U0006F4D1 #t #\Ԯ)
    #f
    (cond
      ((let ((g2 #\U000EDD6B)) -7)
       (let ((j2
              (cond
                ((cond
                   (else
                    (if (if (zero? #t) (abs #\U000B012A) #f)
                        #\瑢
                        (if (integer? #\玺)
                            (cond (#t -4) (else #\渤))
                            (cond
                              (#t 1)
                              (#\U0003D875 #t)
                              (#f 0)
                              (#t #t)
                              (else #t))))))
                 #\ꫪ)
                ((let ((q2 #f)) -3) #f)
                (else #\U000BDAD8))))
         #f))
      (else #f))
    (if (cond
          ((cond
             (else
              (if (if (if #t (integer->char #\u2D6A) #f) #f (if #\읣 #t #t))
                  (integer->char #t)
                  #t)))
           (let ((v2 (if #t #t -3))) (let ((g1 #f)) 8)))
          ((cond (#f #f) (#\U0010D08B -5) (else #f)) #\U000F9BA5)
          (#f (add1 (let ((f0 #t)) 3)))
          (else #f))
        #\뻦
        #\U0003B9D9)
    #f
    #t
    #\披
    #t
    #\U0010EBA2
    -1024
    #f
    #f
    #t
    (cond (else (sub1 #t)))
    (if (let ((a1 #f)) #f)
        (let ((s0 #t))
          (cond
            ((char->integer s0) s0)
            (-11 (if #\U000B70FB #\윣 #\φ))
            (s0 (let ((y1 #t)) #f))
            ((abs #f) #f)
            ((if -2 s0 s0) 1)
            (#\ᚣ (let ((c1 #\緼)) c1))
            (else -1)))
        (let ((c1 #t)) (cond (else c1))))
    #\ቍ
    (add1 -2)
    3
    #t
    #t
    (cond (else -2))
    (cond
      ((cond
         ((cond
            ((cond ((integer? -5) (if #t 1 #t)) (#t #t) (else #t))
             (cond (else #\𒁭)))
            (#\ắ #f)
            (#f #\U0008DE52)
            ((cond
               (#f #t)
               ((cond (else #\玖))
                (cond (#f #f) (#f #t) (#\짶 #\U000D0B16) (else #t)))
               (#\塙 2)
               ((if #t #t #\㖪) #\U000751CB)
               ((if #t #t 2) #t)
               ((if -1 #f #\u209F) #t)
               (else #\U0008EB8E))
             (cond
               ((char->integer #t) (if #\빀 #f #f))
               (#t 4)
               (-2 #f)
               ((cond (#t #f) (else #f)) (integer? #\᥌))
               ((if #\U00067B75 #f 2) (char? #f))
               ((if #\붺 1 #f) 4)
               ((boolean? 1) #f)
               (#t (integer->char #f))
               (else #t)))
            ((if #\U000A9BEF (if #f -1 #\U0006F825) (if #f #f #t))
             (cond
               ((cond (-2 #f) (#\ႈ #f) (else #\U0009D5BE)) #t)
               ((cond (#f #\U0006ACCD) (#\U000539A8 #t) (#t 33) (#f #t) (else #t))
                (if #\U00078FC2 #\U00092BCD -1))
               (#\U00082E3E #\U0001B6FF)
               (#f (if #f #t #f))
               ((cond (else #f)) (if #\㦎 4 #f))
               ((zero? #t) #t)
               (#\Ꚓ (if #f #\U000E6806 #\‿))
               (#f (abs #f))
               (0 -17)
               (#t (zero? -2))
               ((if #\련 #f #t) 3)
               (#t
                (cond
                  (#\腲 -1)
                  (1 #\U000C6C98)
                  (#\爂 #\U000AD9FE)
                  (#t #\U00019466)
                  (#f #f)
                  (2 #f)
                  (#t -2)
                  (#\湱 #\䁽)
                  (#t 1)
                  (#\ṿ #t)
                  (#\쿮 #f)
                  (#t #t)
                  (-3 #f)
                  (#f #t)
                  (-6 4)
                  (-1 #t)
                  (#t #\騽)
                  (#t #t)
                  (#t #\ꜵ)
                  (#\⏑ #t)
                  (#\˝ #\U0006277A)
                  (#f -18)
                  (#\耋 #\놲)
                  (3 #\U000A8E4A)
                  (else -2)))
               (else #\U0010C2B7)))
            (else
             (if (zero? #\uAB97)
                 (cond
                   (8 #t)
                   (#t #t)
                   (#\U0006420B #f)
                   (#t #f)
                   (#t #\騜)
                   (#f -2)
                   (else 0))
                 #\魡)))
          (char->integer (if (integer? #f) #\蟄 -5)))
         (#f #t)
         (#f
          (if #t
              #f
              (cond
                (#f #\U000F90BA)
                (#t #t)
                ((cond (#f #f) (#f #\U000C76E0) (#t #\듎) (#t #f) (else #f))
                 (if -34 #\䫑 #f))
                (#f
                 (cond
                   (#t #\洘)
                   (4 #\䟧)
                   (#f #\摥)
                   (-8 #\U000C1C04)
                   (#f #\U000EE79B)
                   (2 #\U0010C75B)
                   (-4 #t)
                   (#t #f)
                   (#t #\U000A67F7)
                   (#\笄 #t)
                   (#t #t)
                   (#\U0003CFE8 -1)
                   (else #t)))
                ((char? #\U000D6957) (if #t 6 1))
                (#f #t)
                ((integer->char #\윛) (cond (else #\䦫)))
                ((cond (else #\U0006E3FB)) #t)
                (else (if #f #\U0009B8B5 #t)))))
         ((add1 (cond (else (cond (else #t))))) 0)
         (else
          (cond
            ((char? #t) #f)
            ((if #t (- #\ᨄ) (cond (else #t))) (char? (char->integer #\U00103DF7)))
            (else #t))))
       #t)
      (#f (let ((r0 (cond (else (let ((j0 #t)) #t))))) (sub1 2)))
      ((let ((r0 (sub1 (char->integer #t)))) #\U000AF1A8) #t)
      (#f #\U000DCC0C)
      ((cond (else #t)) #f)
      ((if #f
           #t
           (if (if #t
                   (cond
                     (#\U0008FF62 #f)
                     (#f (cond (-16 -3) (#\쮜 #\첑) (else #t)))
                     (-16 (integer->char #\乱))
                     (-1 5)
                     (else (cond (else #\U000C72CC))))
                   (cond
                     ((add1 1) (if -3 #f -1))
                     (#t (- #f))
                     ((add1 #t) -2)
                     (#t (char? #t))
                     ((zero? #f) #f)
                     (#f (cond (#f -1) (else #t)))
                     (#f (if #\U00083829 #\ᵭ #f))
                     (#t #f)
                     ((cond (#t #f) (#\뤸 #t) (-1 #t) (#t -4) (else #\U0005811A))
                      (- #t))
                     (#\U000A0556 (if #\ᓵ #\U000B4063 1))
                     (-5 (abs #t))
                     (-2 (cond (-4 #\U0009CA5D) (#\㔀 #f) (#f #f) (#f -2) (else #t)))
                     ((- #\U00104281) (- #\蝘))
                     (#f (if #\U000CD792 -1 #\ꆂ))
                     ((cond (1 -8) (3 #t) (else -1)) (cond (-2 #f) (else #t)))
                     (3 (- -2))
                     (-1 #t)
                     (#\U00105619 #f)
                     (-2 (cond (else #f)))
                     (3
                      (cond
                        (#t #\媭)
                        (#t #\U00090DEE)
                        (#f #f)
                        (#f #\U000D9503)
                        (1 #f)
                        (#t #\U000CAAED)
                        (#t -1)
                        (else #\綀)))
                     ((if #\갥 0 0) #f)
                     ((sub1 #\U000BEE41) (if 5 #t #f))
                     (#\U000A2E6B #\U000FD7F2)
                     (#t 2)
                     ((cond (#\ꢤ #\U00083CDB) (#\U000CF20B -2) (else #t)) -1)
                     ((cond (#\U000796A4 #f) (0 #f) (else #f)) (char? 10))
                     (3 (zero? #f))
                     (0 33)
                     (#t (integer->char #t))
                     ((cond
                        (#t #t)
                        (-2 #\愆)
                        (4 #t)
                        (#f 64)
                        (-2 -1)
                        (#\罩 #f)
                        (#\U00053AD7 -2)
                        (else #\U000CCC56))
                      #\᷿)
                     ((cond (#t -5) (else #\U0009018D)) #f)
                     (-16 #t)
                     (1 #f)
                     ((abs #\U0007C90C) (if #t #\U000AD002 -2))
                     ((if #t 2 #\㆜) 1)
                     (#t (if 2 #t -5))
                     ((if #t #f #\뇐) #\U00034A34)
                     ((if #f #t #t)
                      (cond
                        (#f 0)
                        (#f #\U000D4167)
                        (#t #\㤟)
                        (#f 0)
                        (#t #\U000BAECF)
                        (else #t)))
                     ((cond (#f 2) (#f #\𧉛) (else #\U00042FF0)) #t)
                     ((cond (-3 1) (3 #\拆) (#\U0009376A #f) (#f #\ᒖ) (else -2))
                      (if #\U00051D26 #\U000A9CAC #\U000604F3))
                     ((cond (else #t)) (abs #\U000F2A7D))
                     ((if 5 #\朄 #f) -5)
                     (#\U000FB987 #t)
                     (#f (abs #t))
                     (#t 16)
                     (#\U0010F594 (add1 #\뱮))
                     ((cond (-4 2) (else -3)) (if #f #\U0005D47A #f))
                     (#t (cond (-5 11) (#f 1) (#f 3) (else -2)))
                     (else (cond (#f #t) (#t #t) (else -3)))))
               #t
               (- #\u0BDA)))
       (let ((j2 #f)) -4))
      (#t (add1 #t))
      (#f
       (cond
         ((let ((i1 #f)) i1) #f)
         (-4 #t)
         (1 1)
         ((cond
            (#f #\蟲)
            (#f (char? 3))
            (#\U000E0933 (if #f #\U000E17A4 #\잝))
            (#t 2)
            ((integer? 2) (let ((y1 #f)) 1))
            ((cond (else #f)) #t)
            (#\说 (if #f 0 #\U00017A2F))
            (#\⌼ (if #\鳚 #t #t))
            ((integer->char -2) (boolean? 2))
            (#\U0005E237 6)
            ((if #t
                 (cond
                   (-1 #t)
                   (#\𧥚 #\나)
                   ((add1 #\U00017310) #t)
                   (#t (integer? (zero? #\ാ)))
                   (#\U000F7F66 #t)
                   (#t 5)
                   (#f (if #f 2 (sub1 #f)))
                   (else 1))
                 #\U00053516)
             7)
            ((if #f -258 #\䏀) (zero? 1))
            (else #t))
          -1)
         ((cond
            (else
             (cond
               (#t #f)
               (#f #f)
               (-1 1)
               ((cond
                  (-1 #t)
                  (1 (cond (#f -4) (#f #f) (2 #f) (#t 3) (0 #\㮽) (else -1)))
                  (#\U000797F7
                   (cond
                     (#t #f)
                     (1 #\ꔊ)
                     (#t -5)
                     (1 #f)
                     (#t #\Ż)
                     (#\甃 #\U0004ED81)
                     (#t 5)
                     (#\䚊 #t)
                     (#t #\𩥗)
                     (5 -4)
                     (#f #f)
                     (1 -3)
                     (#t -3)
                     (#t #t)
                     (#f #\헶)
                     (#t 3)
                     (else #\겁)))
                  ((cond (#t 1) (1 #f) (else #\ꇓ)) (if #t #t #t))
                  ((abs #t) 4)
                  ((if #f #\毯 #t) (abs #\U000D4A08))
                  (#f 5)
                  (#f #\伢)
                  (else #t))
                (cond
                  ((if #f #f #t) #\䴊)
                  ((if 2 #\U000B9BED #f) (zero? 2))
                  ((- #f) (zero? -1))
                  ((char? #f) #t)
                  ((integer->char #t) (cond (else 5)))
                  (#t #\鯿)
                  ((sub1 #t) #\U000E109C)
                  ((cond (-2 #\U000C35E5) (#f #t) (else #t)) #f)
                  (#f #t)
                  (-1 (if #t #t #t))
                  (#f (cond (else #f)))
                  (8 (cond (else #f)))
                  (3 (abs -1))
                  ((cond (#f #t) (else #t)) #t)
                  (-1 #\U000E22A8)
                  (2 (if 2 #f #f))
                  ((if 4 #\U00044EE9 5) #f)
                  ((cond (else #f)) #t)
                  (#\ᢐ #f)
                  ((if #\uA638 #\ꗬ #t) #\U000E97F9)
                  (else #f)))
               ((if #f (integer? #f) #\祧) (integer->char -2))
               (else
                (if (cond (#t #f) (-1 #f) (-2 #t) (#t 2) (else 2))
                    (if #f #f #\雳)
                    (cond (#t #t) (else -1)))))))
          (if #f #f (let ((y0 (if #t #f #\U000759CC))) #\ਾ)))
         ((if #\U000E2DC5 -2 #\ఖ) #t)
         (#f (let ((x2 #f)) x2))
         ((let ((l2 5)) l2) #t)
         ((cond
            (#\⥅ (let ((k1 #t)) #f))
            ((if -4 #f 2) #t)
            (2 (if #\U0008891B #\U0006D2C3 #f))
            (else (boolean? #t)))
          (cond
            (#\U00054D97 #\U000EA9FD)
            (#f (let ((l0 #f)) #f))
            (#f (if #f #f 17))
            (#f (cond (#f #t) (0 8) (2 #f) (#f 3) (else #\䛈)))
            ((if #\沠 #t #\藑) #t)
            ((let ((b1 #\U000E3F20)) b1) #\U000F0F65)
            (#\U000EAA4F
             (cond (#t -5) (#f #t) (#\U00106794 #\쿼) (-4 #t) (else -3)))
            (#f #\㸛)
            (-5 #t)
            (else (sub1 -2))))
         (#f -8)
         (#\U0010F053 #f)
         (#f (add1 (char? (char? #f))))
         ((add1 (if #f #f #f)) (let ((i1 #\U0007B1F0)) (zero? #t)))
         ((if (zero?
               (if #t
                   #\圎
                   (cond
                     (#\㠟 #\⼨)
                     (#t #f)
                     (#t 8)
                     (#f #t)
                     (#f #\컂)
                     (-5 -6)
                     (#f #t)
                     (#\U0003766E 4)
                     (#\U000E1C67 #f)
                     (#t #t)
                     (8 #\㷪)
                     (#\U0009F556 #f)
                     (-5 #f)
                     (#\䓝 #f)
                     (3 #\闩)
                     (#f -2)
                     (#t 1)
                     (else -8))))
              (if (cond
                    (#f #\U000BB58B)
                    (-1 #t)
                    ((cond (#t #\䫕) (#t -2) (#f 2) (else #t)) #f)
                    (else #t))
                  #t
                  -3)
              #f)
          #\奉)
         (else 8)))
      (else #f))
    (if 10
        (if #t
            #t
            (cond
              ((let ((s0
                      (cond
                        (#f (abs (- #t)))
                        (-2
                         (cond
                           (#t #\ᄌ)
                           ((if (cond (else #\U00080BB2))
                                (cond
                                  (2 -2)
                                  (3 #f)
                                  (#\U000A5A5C #\饽)
                                  (4 #t)
                                  (#f #\U000FDF29)
                                  (#\U00085029 #t)
                                  (#t #\ᣚ)
                                  (#\獹 #t)
                                  (#f #f)
                                  (#\툭 #f)
                                  (else -5))
                                #f)
                            #\즱)
                           (#f #f)
                           (#f #t)
                           (else 4)))
                        ((cond
                           (#\U0009A86B (sub1 (integer->char #t)))
                           ((zero? (if 1 #\𫜟 #f)) #t)
                           ((if #t #t 1)
                            (if (cond
                                  (-1 #f)
                                  (#\U0002F3C4 -1)
                                  (#f #\븕)
                                  (#t #t)
                                  (#f 5)
                                  (#t #\U0006BA6B)
                                  (#t #t)
                                  (else #\U000D805A))
                                (cond (else #f))
                                #f))
                           (else #t))
                         #f)
                        ((cond
                           (#\U000CBBC0 #f)
                           ((char?
                             (cond
                               (#f #\U00073515)
                               (-1 #t)
                               (3 #\U000D9011)
                               (#\U001063F6 0)
                               (#t #t)
                               (#t #\ꈈ)
                               (2 #f)
                               (#f #t)
                               (#f #\U0002CEBB)
                               (-1 #\DŽ)
                               (else #f)))
                            (cond
                              ((- #f) (sub1 #f))
                              ((if #f #f #f) (integer? #t))
                              ((if #\U000EC388 #t -4) (if #t -4 #\近))
                              (#t #\U000805B8)
                              (#f 16)
                              (else (sub1 #t))))
                           ((if #f #\𝘸 (char? -4))
                            (cond
                              ((if #\U000359A9 2 1) #f)
                              ((- -1) (cond (0 -6) (else #\U0008CC56)))
                              ((if 3 -2 #f) #\ᒕ)
                              (else (if -2 2 #t))))
                           (else #\U000C8D5F))
                         #t)
                        ((add1 (cond (#\U0002C297 (if #t #\뱤 4)) (else #\𢌭))) -1)
                        (-4 #f)
                        (#t #f)
                        (else
                         (cond
                           ((char? (zero? #\U00096A5C)) #f)
                           (-4 #t)
                           (#f #f)
                           (#t (cond (else -3)))
                           (#f
                            (if (if #\U000362BE #\U00070A5D #t)
                                (if #t #f #t)
                                (boolean? #t)))
                           ((cond ((integer->char 2) (integer->char 3)) (else 2)) #f)
                           (#t
                            (cond
                              (#f #t)
                              (#\튵 #\U0009DFAF)
                              (-4 (if #t #\잶 #f))
                              (else #\U00064372)))
                           ((if #f #f (boolean? #\uA959)) 2)
                           (#f 2)
                           (else 5))))))
                 -8)
               0)
              (32 (if #f #\슏 #f))
              ((integer->char #t) (sub1 #\㣧))
              (else
               (let ((s0
                      (char?
                       (add1
                        (if 3
                            (if #f #\U000EE467 1)
                            (if #\U000F424B #\U000E7981 #\U000FDEF6))))))
                 -2))))
        (let ((o0 (if (if #t #t #t) 2 (let ((l2 #\U00044BFF)) -3)))) o0))
    (let ((v2 #t)) v2)
    #t
    (char? (abs #t))
    (let ((o1 (if 16 4 (integer? (integer? #\顾))))) #f)
    (if (cond
          ((let ((c0 (let ((f2 #f)) -4))) (- c0)) (- #\U0007002B))
          (#\U000ECC79
           (cond
             ((if 2 #f #f)
              (cond
                ((add1
                  (cond
                    (#\U000A38B9
                     (integer->char (cond (#t #t) (#t #\朴) (1 #\媯) (else -3))))
                    ((cond (#f -8) ((if 5 #\賃 6) #f) (else #\衻))
                     (if #\U000B401C
                         (cond
                           (2 #t)
                           (#\τ #\U000B17D3)
                           (-2 #\U00031C4B)
                           (#t #f)
                           (#t -4)
                           (#t #t)
                           (2 #\쭟)
                           (#t 5)
                           (#f 1)
                           (#t #f)
                           (#t 4)
                           (#t #t)
                           (else #t))
                         (if #t -3 -4)))
                    ((cond (#\ጮ (if #f #t #t)) ((integer->char 64) #t) (else 0))
                     (integer->char -3))
                    (#t #f)
                    ((zero? #t)
                     (abs
                      (cond
                        (#\ᾗ #f)
                        (#t #t)
                        (#\햿 -4)
                        (#t #\U000D1271)
                        (#f #t)
                        (else #\U0003A947))))
                    (#f
                     (cond
                       ((if #\ላ #f #\递) #t)
                       (#\榾 #\뭻)
                       (#t #t)
                       (0 #\U000FB1CB)
                       ((if #f #\𠘦 #\ᒤ) 14)
                       ((cond (#\u08DA #f) (#t #f) (#f #t) (4 #t) (#\ꋾ 8) (else #t))
                        (if -1 #f -2))
                       ((zero? #f) (char? #f))
                       ((cond
                          (#\u0884 0)
                          (#t #f)
                          (#\ᔘ #\⿳)
                          (-3 #f)
                          (#f #t)
                          (else #f))
                        #\U00047DD0)
                       (#\U000BD8C3 #f)
                       ((char->integer 6) (- -5))
                       (#\ꋕ 4)
                       ((char->integer #f) (sub1 #t))
                       (#f (- #f))
                       ((cond (else #t)) #\U00036017)
                       (-3 (if #\U000FBD9E #f #t))
                       (else #f)))
                    (-6 (zero? #\U000561DD))
                    (else #f)))
                 #t)
                (#\䏑 -513)
                (#f #\U0007CBB0)
                (#\U00104DB7 -2)
                (#t #t)
                (#f 2)
                (else #t)))
             ((- #\왴) -4)
             (-1 (char? #\䰾))
             (else (let ((v2 #t)) #f))))
          (else #\U0010D72D))
        #\隙
        (let ((i2
               (cond
                 ((if 6 #t #\髓) -2)
                 (#t #f)
                 ((cond (else (cond (else #\끲)))) #t)
                 (#t 3)
                 (#f #t)
                 (#f (if #\U000CE18B #t #t))
                 ((let ((b0
                         (boolean?
                          (cond
                            (#f
                             (if (cond
                                   (#t #f)
                                   (#f #\U000C53B2)
                                   (#\팅 #t)
                                   (#f #\U000F1741)
                                   (#t #f)
                                   (#\U000A3F15 #t)
                                   (else #f))
                                 (cond (-2 #\ᜩ) (else #\U000BA067))
                                 (- 1)))
                            ((if (- #f) -1 #\U000128E5) (abs #t))
                            (else (if #\U000F1760 #\⟻ #\U000C8B4E))))))
                    #\鲭)
                  #t)
                 ((cond
                    (#f #\U0004F700)
                    ((cond
                       (#t (cond (1 (- -1)) (else #f)))
                       ((cond
                          ((if (cond (#t #f) (#f #f) (#f #\𤬨) (else #f))
                               3
                               #\U00109E3C)
                           #f)
                          (#\U000BA146 (cond (else (sub1 -2))))
                          (else 17))
                        5)
                       (else (if #t #f #\𠞛)))
                     #t)
                    (#t #f)
                    (else #\ꉗ))
                  #t)
                 (else #\U000D5DA0))))
          (if #f (if #f #\U000F3BDE #\U000847BF) i2)))
    -2
    (cond
      (#f (cond (else #\u2069)))
      (#t 1)
      ((let ((h0 2)) h0) (cond (#f (char? 8)) (else (zero? (if #\捻 #f #\丄)))))
      ((if (char? #f) #f (add1 #t)) #\U0008A1BB)
      (else
       (let ((c2 (let ((s0 (sub1 #f))) (if 1 #\U000CAAA5 -1)))) (sub1 c2))))
    #t
    (cond (else (boolean? #t)))
    (if #t
        (let ((u0
               (if #\U000347B6
                   (let ((z2 #\U000EFA53)) -5)
                   (cond
                     (#f #f)
                     (#\繵 #\U000A5BE2)
                     (#\ꑖ 2)
                     (#\U00044751 #\U00088BB2)
                     (#t #t)
                     (#\𠭪 #\U000BC79D)
                     (-2 #t)
                     (#\킧 #\ᘛ)
                     (else #f)))))
          #t)
        (if 2 #t (let ((t2 -5)) #t)))
    (integer? #t)
    (let ((c0 (cond (else #f))))
      (let ((n2 (if (zero? c0) (cond (-4 #\U000E053B) (c0 #t) (else c0)) 2)))
        c0))
    #t
    1
    (if (sub1 (let ((x0 (let ((p2 1)) #f))) x0))
        (if (integer->char
             (if (cond (#t -2) (#t #\U00017637) (3 -1) (else #t))
                 #t
                 #\U0003A105))
            (cond
              (#t (if (if #\U00078F10 5 -3) #f 8))
              (17
               (cond
                 ((integer? #\U0001E0E6)
                  (cond (#\ⶐ #f) (#f #\椎) (#f #\U000782A0) (else #t)))
                 (#t (if #t #\三 3))
                 (#f #f)
                 (#t -8)
                 (#t #t)
                 (2 -2)
                 (-8 #f)
                 (else (if #\敔 #t -2))))
              ((char->integer (integer->char #f))
               (cond
                 ((integer->char #f) #\驽)
                 (#t (char->integer -5))
                 (#f -1)
                 ((sub1 #t) (if 6 2 #f))
                 (#t
                  (cond
                    (#f #\쎙)
                    (#\U000ACEE0 #f)
                    (#t #t)
                    (#\潪 #\U0008B0E2)
                    (-1 -1)
                    (64 #t)
                    (#t #\U000E37CA)
                    (#\U000DA0BB #\嵾)
                    (0 -5)
                    (#f -2)
                    (else #f)))
                 ((if -1 #t #f) 0)
                 (#t #t)
                 ((if 6 -1 #\䗊) (add1 #\U000ACC8F))
                 (#f (cond (#t #\U000EC0D0) (#f #t) (else -1)))
                 ((cond (else #f)) 5)
                 ((integer? #f) (if #t #f #t))
                 (else (if #f #\邤 #\U000E91AC))))
              ((cond
                 (#f (cond (-2 #t) (#\𡧑 #\U000B1112) (else #t)))
                 ((cond (#f #\嫃) (else #\斅)) #t)
                 (18 #f)
                 (else #f))
               #t)
              ((if (integer? #\U000EF079) (cond (-1 #f) (else #t)) #t) #t)
              (#t #\䕐)
              (#t
               (if (cond
                     (#f #t)
                     (#\U000505DE -1)
                     (#t #t)
                     (#f #f)
                     (#f #t)
                     (-1 #\𣕞)
                     (0 #t)
                     (9 #t)
                     (#\U000F0D23 #\U000FF9E5)
                     (#f #t)
                     (#\Ԧ #\䄈)
                     (#\𡛏 -1)
                     (#\㼮 #\䒌)
                     (else 1))
                   (abs #t)
                   (integer? -5)))
              (1 (sub1 (if -1 #f #f)))
              ((if #t (cond (else #t)) (integer? #f)) #f)
              ((if (char? #t) (if -256 #\U000E5772 #\럙) -2) 3)
              (#t (integer? (sub1 2)))
              ((cond (#\± (integer->char #f)) (else #f)) #t)
              (#f #t)
              (#f #\u001D)
              (#f (abs (cond (#f 0) (#\㟷 #f) (2 7) (1 #\u0A0C) (else #t))))
              ((cond
                 (#f 2)
                 ((cond (#f 1) (else #\셝)) (integer->char #\U0002D18B))
                 (#\鹼 0)
                 (else (- #\U0008683F)))
               (add1 -2))
              ((cond
                 (#\똩 (char->integer #f))
                 ((if -3 #t #f) (cond (#t 2) (else #\U00099FC6)))
                 (1 (if #\U000502EE #t #f))
                 ((integer? #t) 0)
                 (0 (if #\査 #f #t))
                 ((cond (#\둀 #\U000CE8AD) (-1 11) (#\⮫ #t) (else #f)) -1)
                 (3 (char? #f))
                 ((if #f #\塾 #f) #f)
                 (#f #f)
                 (#f #\붓)
                 (else (cond (-2 -3) (-4 #t) (else #f))))
               #\U000F2412)
              (else #f))
            (cond
              (3
               (cond
                 (#f (cond (#f -7) (#\錵 #f) (#t #t) (#f #t) (else 4)))
                 ((sub1 #f) -18)
                 (#f #f)
                 ((cond (else -3)) #t)
                 ((char->integer #\臀) #t)
                 (#f
                  (cond
                    (#t -2)
                    (-2 1)
                    (#\䁥 #f)
                    (#t #f)
                    (#\㐀 #\횷)
                    (#f #f)
                    (#\U000BE5EF #\U000702EA)
                    (else #f)))
                 (#\齗 #f)
                 (#f #f)
                 (else (cond (else -1)))))
              (#t
               (cond
                 ((if #t #t #f) (char->integer #f))
                 (-5 #t)
                 (-3 (cond (else #f)))
                 ((cond (-8 #f) (#t 1) (else #f)) #f)
                 ((cond (#\U00078D26 #t) (#\U000CD0AC #t) (else -2)) (- #f))
                 (-2 #t)
                 ((if -4 #f #\톤) -16)
                 (#\긻 #\죪)
                 (else #\U00100CEB)))
              (#f -4)
              (else #f)))
        (zero? 4))
    (cond
      ((cond
         (#t (cond (#\埬 #f) (else #f)))
         (#\U000C634B (let ((f0 (add1 2))) (if f0 #f #\U0005C480)))
         (else (sub1 6)))
       #t)
      (else (if #\້ #\U0006742A #\U0004196D)))
    #f
    (if (cond
          (#\uEA75 (zero? #f))
          ((if #f (if #t #f #f) #t) (integer->char #t))
          (19 -2)
          (#\뿃 #t)
          (#t #\U00073553)
          ((if #\U0001B9BC (if #f 1 #\ꀘ) (add1 #\𧤃)) #t)
          ((if (cond (else #\U00044B95)) (if #t 4 #t) #\㦶)
           (if (boolean? #\㦉) (zero? #t) -8))
          ((cond (1 (if -2 #t 1)) (else #\堗)) #f)
          ((if #f 3 #t)
           (if #\붠
               #t
               (cond
                 (#t #\U000360AD)
                 (#t #\U001093CF)
                 (#\U0008689F -1)
                 (else 1))))
          (else
           (if (if #f #f #\U0005BD46)
               (cond (-1 #\U000C8608) (#f -4) (else -1))
               (integer? #t))))
        #t
        (zero? -2))
    #t
    (integer? 0)
    -2
    (char? 17)
    (abs #f)
    (if (if #t #\䫈 -5) (let ((l2 #t)) #f) #\㓹)
    #t
    (if #f (cond (else #t)) (if #f (zero? #\U000A38FE) 3))
    #f
    #f
    5
    #\U00103389
    (integer? (let ((g1 4)) (let ((n0 #f)) #t)))
    -3
    (integer?
     (if #t
         (if (if #f -1 #\U000A17E8) (integer->char #f) #t)
         (cond
           ((if #\坕 #f 1) #t)
           (else
            (cond
              (2 4)
              (#\U0004EF24 #t)
              (-9 -4)
              (-4 #\U000B1473)
              (#t #\U000F2A2D)
              (#f 2)
              (#f #f)
              (else #t))))))
    #f
    #\U00046EF6
    (cond
      ((if (sub1 #f) -1 #f) #t)
      (#t #t)
      ((let ((a1 (if #t #\癇 #f))) a1) #t)
      (#f #t)
      ((if #\㳧
           (sub1
            (cond
              (#t #\U00074A98)
              (#f #\椔)
              (#t (if #\U000E2A7B -128 (if 1 #f #\쌪)))
              (#f (if #t #f (- #t)))
              (#t
               (cond
                 ((boolean? #t) #\U000DF06B)
                 (#f (integer->char #\∂))
                 (#t -7)
                 (else (integer? #f))))
              (0 2)
              ((if -3 2 -2) -3)
              (#t (integer->char (if 0 #\U0001388B #t)))
              (#t #f)
              ((cond (else #f))
               (cond
                 (-3 #f)
                 ((cond (#f #f) (-8 2) (else #t)) #\uEA9F)
                 (#\U0003D242 #\U0009240B)
                 (else 8)))
              (else -2)))
           5)
       (integer->char 1))
      ((sub1 #f) (char->integer (if #\U0002CD68 3 3)))
      (#f (sub1 #\U000D7D69))
      ((cond
         ((integer? 4) (let ((o1 #\U00082A7D)) (let ((a2 #\ᖫ)) 0)))
         (-4096 3)
         (#\U00017CC0
          (if #f
              (cond
                (#\厁 #\쯁)
                (#f (cond (else (- #t))))
                ((cond
                   ((cond (else -2))
                    (cond
                      (#\U00071827 #f)
                      (-1 128)
                      (#t #f)
                      (2 #\U0002F372)
                      (#\U0003BB31 #t)
                      (1 #t)
                      (#f -128)
                      (#t #\U0005A4FE)
                      (#f #\壌)
                      (#t #f)
                      (-3 #f)
                      (#f #\糰)
                      (#f #f)
                      (#f #\쒜)
                      (#\U000E1B2A #t)
                      (#t #\U0006152F)
                      (else #\U0005C546)))
                   (#f -2)
                   ((cond (#f #f) (#t 1) (else #t)) 4)
                   (#t #t)
                   (#t (char->integer #t))
                   (else -2))
                 #t)
                (#f #\U000C4189)
                (#\U000503D0 8)
                (#\皍 (char? #\U0006757D))
                (else -8))
              #t))
         ((let ((k2 #t)) (let ((t2 -2)) #t))
          (if (cond ((zero? #t) #\U000FED3C) (else (sub1 #\U0005C3B3))) #t #t))
         ((abs -4) #\䅻)
         (#\鎑 #\炣)
         (#f
          (if 5
              (if (abs #f)
                  (cond
                    ((cond (#f (boolean? #\늸)) (else #\ᒓ))
                     (if (if 4 #t #f)
                         #f
                         (cond
                           (#t #\U00074E73)
                           (#t 0)
                           (#f #f)
                           (#f -1)
                           (#t #f)
                           (else #\豛))))
                    ((cond
                       ((cond (2 #t) (1 #f) (else #t)) -3)
                       ((char? #\䇂) (add1 3))
                       (#t (if #f #\冱 -2))
                       ((char? 3) #t)
                       ((sub1 #t)
                        (cond (#f 3) (2 #t) (#f #f) (#t -6) (3 #\鳩) (else #t)))
                       ((char->integer #t)
                        (cond (-4 #\U00019452) (#f #\ꚻ) (#\᧮ #f) (else #t)))
                       (#f #\U0010B4B2)
                       (#t #f)
                       ((- #f) #\猓)
                       (#t (- 1))
                       (else (if #f #\뺃 #f)))
                     -32)
                    ((cond
                       (-3 (if -6 #f #t))
                       ((integer->char -9) 1)
                       (9 #t)
                       (else (zero? #t)))
                     #f)
                    (else (char->integer #\U0010966F)))
                  #f)
              (char->integer #f)))
         (#\棑 #t)
         (else (zero? 2)))
       (zero?
        (if (cond
              (#f (if #\謣 #\u0A92 -3))
              (#\U00054995 -3)
              ((- #t) (cond (else #\ಶ)))
              (0 (sub1 #\廷))
              (#f 4)
              ((sub1 #f) 2)
              (else -2))
            #\U0008D603
            #t)))
      (else (integer->char #\蘕)))
    (integer? (if #t #t (let ((z1 (integer->char #\譊))) #\棘)))
    (let ((a2
           (if (cond (else (let ((n0 (abs (if 1 -3 #f)))) n0)))
               (if (cond (-4 2) (else 1)) #f #f)
               (cond
                 (#\湈 #f)
                 ((sub1 #t) (let ((l2 5)) #t))
                 ((cond
                    (2
                     (boolean?
                      (if #t
                          (cond
                            (-130 -2)
                            (2 #\碎)
                            (1 #t)
                            (#\U000CE1E3 #t)
                            (2 #t)
                            (#f -6)
                            (#f #f)
                            (#\절 #\U0005B817)
                            (else #t))
                          (cond
                            (#t #f)
                            (#f -1)
                            (#\쮱 #t)
                            (-2 #\챙)
                            (6 #t)
                            (#\U00106F0E #\U000544B2)
                            (#\U000AA1AC 1)
                            (#\륵 #\U00095A66)
                            (else #\䘂)))))
                    (#t 1)
                    (#t #f)
                    ((if #f #f #\U00036D35)
                     (cond
                       ((if (integer? #\U00058842) #f #\U00036E49)
                        (cond (else (zero? -8))))
                       (-1 #\ᆌ)
                       ((if #\U000C15F3 (if #f #t #\栱) #t) #\U0010DDEE)
                       (else (cond (else #t)))))
                    ((cond
                       ((char? #t)
                        (if (cond
                              (#f #t)
                              (#\嬙 #\U00017EB9)
                              (#t #f)
                              (5 -2)
                              (#\U00018DAA 2)
                              (#\착 #\U000DCAC9)
                              (#t #t)
                              (#\U0007436F #t)
                              (7 #\U000181CE)
                              (#\U0007AAD2 -1)
                              (#\U000BE427 #f)
                              (else #t))
                            #t
                            (if #f #\ᆞ 3)))
                       (else -2))
                     (if #t
                         #\u0A78
                         (cond
                           ((if #f #f 1) -1)
                           ((char? #f) -2)
                           (else (if #t #t 4)))))
                    ((if (add1 3)
                         (if #f #f #f)
                         (cond
                           ((cond
                              (-3 -3)
                              (#f -2)
                              (#\몭 1)
                              (-8 #\U00071D25)
                              (#t #\U000141A9)
                              (#f -1)
                              (1 #\U00070466)
                              (#f #\U000A4EB8)
                              (else #f))
                            (if #f #t #t))
                           ((if #t #t #f) #f)
                           ((cond (#\U0004CB11 #f) (else 1)) #t)
                           (else 9)))
                     (if (cond (-8 #\Φ) (else #\ⶠ))
                         (if -4 (if #t #\ༀ -9) (cond (else -1)))
                         (integer->char 5)))
                    ((char? (char->integer #t)) #t)
                    (else (integer? (boolean? #\婂))))
                  8)
                 ((let ((u1 (cond (else (if #t #t #f))))) #\ꗶ) (let ((f0 1)) -4))
                 ((let ((n1 #f)) #f) (abs #t))
                 (-10 #t)
                 (else (integer? #t))))))
      #t)
    #t
    (zero? -4)
    #t
    (let ((f1 #t)) #f)
    -3
    #\U00031D6E
    #t
    #\䖴
    #\刽
    3
    (cond ((integer->char #f) #f) (#\U000BF254 #f) (else #t))
    (cond
      ((cond
         (#t (char? #t))
         ((cond (else #t)) #\②)
         (2 #t)
         (else (integer->char #t)))
       (if #f
           #\᭭
           (if (if #\U000DB85F #\鴡 #t)
               #t
               (cond (1 16) (#f (char? #\࿌)) (else #\ὀ)))))
      ((sub1 -5)
       (cond
         ((let ((n2
                 (if (cond
                       ((cond
                          (#f (integer? -2))
                          (#\U0004A09A (if -69 #f #\в))
                          ((cond (#t (if 3 -4 -5)) (else #f)) 2)
                          (else #\U000B316C))
                        #\U00105BEB)
                       (#f #t)
                       ((if #\꾌
                            #t
                            (cond
                              ((cond
                                 (#\U0007C692 -16)
                                 (#t -3)
                                 (5 #\U000432B2)
                                 (-3 #f)
                                 (#f #t)
                                 (#\솃 18)
                                 (#\U0001B315 #f)
                                 (else -512))
                               #t)
                              ((cond (#\U000CCBC1 #f) (else -3)) #f)
                              (#t #\U00034830)
                              (else #f)))
                        (cond (else #f)))
                       (#f #f)
                       ((add1 #f) #t)
                       (-2 -5)
                       ((if #\ꖓ
                            #f
                            (if (cond
                                  (-5 #\⦁)
                                  (#\U000E879C 2)
                                  (#f #t)
                                  (else #\U0007ABAB))
                                4
                                -4))
                        #f)
                       ((if (if (cond
                                  (-64 #f)
                                  (1 #f)
                                  (#t #t)
                                  (0 2)
                                  (#f #f)
                                  (#\ꬫ -5)
                                  (4 #f)
                                  (5 #\U00075227)
                                  (#t 2)
                                  (else #\윹))
                                #t
                                #f)
                            (if #t #\꾟 (cond (#f #f) (else #\U0001C02E)))
                            #t)
                        (integer->char
                         (cond
                           (#\U00058E60 #\칋)
                           ((if #f #\U00109166 #t) (if #f #t #f))
                           ((integer? 16) #t)
                           (else #f))))
                       (else
                        (cond
                          (#\캦 -2)
                          (#t #f)
                          ((cond (#f #f) (else 1)) #t)
                          (#f #f)
                          ((cond (#\ヴ #t) (else 0)) #\U00090E58)
                          (-2 2)
                          (#t #f)
                          (#f #\茵)
                          ((abs #f) #t)
                          (#\伳 #\롦)
                          ((add1
                            (cond
                              (#\U000FAF8D #\퉽)
                              (#f 1)
                              (#t #\粣)
                              (#t 8)
                              (#f #t)
                              (#f #f)
                              (else #t)))
                           (if (if #t #t #\᰷) #\쪔 (if -3 -1 #t)))
                          (2 #f)
                          (else #f))))
                     #\ꢉ
                     (add1
                      (char->integer
                       (cond
                         (#f (abs #\U0001CAB1))
                         ((if #\肾 18 #f) (add1 -8))
                         ((cond
                            (#\U0003E953 -1)
                            (-1 #\U00057FC3)
                            (#\U000FFF53 #\漾)
                            (else #t))
                          #\U000418D9)
                         (else #f)))))))
            #f)
          (cond
            (-1
             (cond
               (#f #t)
               (#f #t)
               ((if -7
                    (if (cond (#t #t) (else (sub1 #\훳)))
                        (if -1 #\U0001FAEE -1)
                        (if #\赣 (integer->char #\U000ED350) 2))
                    (add1 #t))
                #f)
               (else #f)))
            (else (cond (#f 16) (else #t)))))
         (#\浆 (char? #f))
         (#t 18)
         ((if #\몼 (let ((d1 #\U0007B3B6)) d1) #t) (add1 #f))
         (#t (let ((u0 2)) #t))
         (else (char? -4))))
      (#f #\姂)
      ((let ((y0
              (-
               (cond
                 (-1 #f)
                 (#f #f)
                 ((if (if #\ᴟ #\U000A53C2 #f)
                      (if #f #f #\U0006694B)
                      (cond (#t #\崤) (#t #f) (#\լ #\狩) (else #t)))
                  (cond
                    ((sub1 #t) #t)
                    (else
                     (cond
                       (#t #f)
                       (#t #\U0005F618)
                       (#t #f)
                       (1 #t)
                       (#t #f)
                       (#\U00076017 #f)
                       (#\鞙 #t)
                       (2 -1)
                       (#t -8)
                       (else #\ም)))))
                 (else #\U000CD8C5)))))
         (zero? y0))
       #\U00063A04)
      (0 #t)
      (-2 #t)
      ((let ((a0 -4)) #t)
       (integer->char
        (cond
          ((if -8 #\U000EC6A6 #t)
           (if 4 #t (boolean? (if #f #f (cond (else #\丼))))))
          ((abs #t) #\ꂝ)
          ((cond
             (#f 4)
             (#t #\U0005480F)
             (else
              (cond
                ((cond
                   ((cond
                      (#f #f)
                      (-4 (integer? -4))
                      ((cond (#t -1) (#\U000CAE8E #f) (#f #\袏) (else -2)) #t)
                      (else #f))
                    (if #t (add1 #\춼) #t))
                   ((boolean? #f) #t)
                   (else #\U00059784))
                 #t)
                ((cond
                   ((if 2 (boolean? -10) #f)
                    (- (cond (#\U00084026 #\U000F2828) (#t #f) (#t #\梮) (else 16))))
                   (#\U000175B2 #f)
                   (else #t))
                 #\U00096753)
                (#t #\꾉)
                ((cond (#\믇 5) ((cond (else (if #f #t -256))) (add1 1)) (else 20))
                 4)
                ((if #t
                     #t
                     (cond
                       ((cond
                          (#\弦 #\䵑)
                          (#t #f)
                          (#\U000AB528 #\∿)
                          (#f #t)
                          (#f #f)
                          (-8 #t)
                          (#t -5)
                          (else #t))
                        (abs 3))
                       (else #\၉)))
                 -4)
                ((if #\U00068BEA #f #f) #t)
                ((if #\U00093299
                     (cond
                       ((integer? #t) (add1 -8))
                       (#\죪 #\⦎)
                       (#t #t)
                       ((cond
                          (#\U000CEBCD #t)
                          (#t #\U0002E68E)
                          (#t #\U000D63A2)
                          (#f -1)
                          (else #t))
                        #\U000BCD38)
                       (1 (- 2))
                       ((if 17 #f 2) #t)
                       ((if #\U0006FFFA #t 2) #f)
                       ((cond (#f #f) (#f 2) (#t #\U0010D8E1) (#t #f) (else #t))
                        (cond (#t #\쥘) (#t #f) (#f 1) (else #f)))
                       (#f (if #f #\䛋 -2))
                       (else (if #f -1 #t)))
                     #\U0007A86A)
                 2)
                (#t #t)
                ((cond
                   (1 #\췻)
                   (#\U00072A2F -5)
                   ((cond
                      (else (cond (#f #t) (#t #t) (#f 1) (-2 #t) (#f #f) (else -5))))
                    #f)
                   (else #\U000A9369))
                 #\➗)
                (#\գ #t)
                ((integer->char (char->integer (if #f -4 #f))) (add1 #\俵))
                (else #\␚))))
           #f)
          (#t #t)
          (#\U000639B1 (integer->char #f))
          ((if -5 #\ࢩ #\༠) (integer->char #t))
          ((let ((z1 2)) z1) #\U000F4B6D)
          (#t -1)
          (else #\U0009B2E1))))
      ((let ((f0 (cond ((if 5 #t -3) (if #t 2 #f)) (else (let ((c1 -2)) -5)))))
         #\U000B47A7)
       (cond
         ((if #\U00100CE1 #t #t) #\眠)
         (#t
          (if #\㗨
              (cond
                (3
                 (cond
                   (#t #\U0004AFE0)
                   (#f 5)
                   ((if #f #t (if (if #\U00041B5D #t #t) (add1 #t) (add1 #f)))
                    #\U000F423C)
                   ((if (cond
                          (#\U001075A7 #f)
                          (#\㲝 (add1 #t))
                          (-3 #t)
                          (-19 #\罣)
                          ((cond (#t #\䱲) (#f #f) (#\낇 #\㎾) (#f #f) (else #f))
                           (boolean? #\U0006C381))
                          ((if -32 #f #t) (cond (else 2)))
                          (#\U000AE365 #t)
                          (#f #\U0009F66F)
                          (3
                           (cond
                             (-5 #\U0002DD62)
                             (#f #t)
                             (#f #\U00011EC7)
                             (-3 #f)
                             (#\퇣 -4)
                             (#\쏰 -4)
                             (else #t)))
                          (#\㪷
                           (cond
                             (#f -5)
                             (#\U00055D67 #t)
                             (#t -3)
                             (#f -1)
                             (#\㺪 #\U000ACD67)
                             (#t #\U0004E356)
                             (else #f)))
                          (-2 (if 5 #t #\U0004B6A1))
                          ((if #f #t #f) #\U000D8731)
                          (#t #\껪)
                          ((if 1 #f 1) (if 6 130 #\儒))
                          (#t #\U000AFFC5)
                          ((cond (else 1))
                           (cond (#f #\U0004881D) (#t #\᪼) (4 #t) (else #\瞃)))
                          (#t (if 1 #t #f))
                          (-2 (sub1 #\֘))
                          (#t (cond (2 #f) (#t #\U0006F676) (else #f)))
                          (#\U000D7CE1 (if #f #f #f))
                          ((if #f #t #f) -1)
                          (#t (if #\樞 #\U00105400 -2))
                          ((cond (#t 1) (#\U00094D1E #f) (#f #t) (#f #\谼) (else #t))
                           #t)
                          (#f #f)
                          (#f (cond (#f -6) (#f #t) (else #f)))
                          ((- 9) (if 12 #f #f))
                          (else -1))
                        #\U0006B83B
                        2)
                    #\뇞)
                   (#\U000BE8C1 #f)
                   (-2 (integer? #f))
                   ((cond
                      (#\엠 -2)
                      ((integer->char (add1 8))
                       (cond
                         (#f (cond (else -2)))
                         (#f #\U00108D3E)
                         ((if #f #t #f) #f)
                         ((cond (#t -2) (#t #t) (#\U000495E4 #f) (else #t)) -1)
                         (#t (integer->char 32))
                         (else #\⚺)))
                      (else 2))
                    (if 0
                        #f
                        (if (cond (#\U000EABD7 #\U00047C84) (else #\u0DE3))
                            (cond (#f #\髚) (#\U00032B6B #t) (else 8))
                            2)))
                   (#f #t)
                   (else #f)))
                (else #f))
              -2))
         (#\U000C970D -2)
         ((if (cond
                (#f #t)
                (else
                 (if 6
                     (cond
                       (#t -1)
                       (#\U00052751 4)
                       (2 (cond (#f -2) (3 #\U000B7087) (else #\䰚)))
                       (else #t))
                     (cond
                       ((char? #f) (zero? #\U00099620))
                       (else (if #\U00064EEE #t -8))))))
              (cond (#f #\窅) (else -1))
              (abs #\U000D9723))
          #\U000E3882)
         ((if (cond
                (-2 -3)
                (#\U000F2E5D
                 (if (char->integer
                      (if -2
                          (cond
                            (#t 1)
                            (#\䱮 #t)
                            (#\U000FB28E -2)
                            (#f 18)
                            (#f #\U000C5884)
                            (else #t))
                          (zero? #f)))
                     #t
                     (cond
                       ((add1 #f) (char? #f))
                       (-4 (abs (abs #f)))
                       (#f
                        (cond
                          (#t #t)
                          (#\⏛ -1)
                          (#f #t)
                          ((if #t #\U00060A41 3) (sub1 -2))
                          ((cond
                             (16 #f)
                             (#f #\㛇)
                             (#\U00037915 #\䜄)
                             (#t #f)
                             (-16 #f)
                             (else #\꼿))
                           #t)
                          ((cond
                             (#f -4)
                             (#\U0007CBD4 #\潹)
                             (#f #f)
                             (#t 3)
                             (7 #\U000527B7)
                             (#\U0006C44D #\U000CC264)
                             (#\回 0)
                             (#\U000DC95D -4)
                             (#f 16)
                             (else #\U0004164E))
                           #t)
                          ((sub1 #f)
                           (cond
                             (#f -5)
                             (1 #t)
                             (-1 3)
                             (-2 #f)
                             (#f #\u1C9A)
                             (#t -6)
                             (-2 #f)
                             (1 0)
                             (0 #f)
                             (2 #t)
                             (#\U000F9DB3 64)
                             (#\U000F2E20 #\U000CCABD)
                             (#f #f)
                             (4 #f)
                             (else -3)))
                          ((char? #\蝝) #\鍆)
                          (else (boolean? #t))))
                       ((cond
                          ((- #\U000EDDAD) #t)
                          (#t (cond (else -1)))
                          ((cond (2 -2) (-1 -5) (5 #f) (else #\醛)) (add1 #t))
                          ((cond
                             (2 #\礊)
                             (2 #t)
                             (#t -1)
                             (#t #t)
                             (#t #\ⶇ)
                             (#\U000C5C69 #t)
                             (#\U000B4904 #\U00063F30)
                             (#\æ -4)
                             (-1 -1)
                             (else #\굃))
                           (if #t -7 #\㳼))
                          ((if -1 #t #t) (integer? #t))
                          (#\U00049BB0 8)
                          (#t #\U00073DB3)
                          ((cond (else #f)) (if #f 2 #t))
                          (else #t))
                        (cond
                          (#f #t)
                          ((integer? -16) #t)
                          (4 -1)
                          (5 #f)
                          (#f
                           (cond
                             (#t 4)
                             (4 -2)
                             (-4 -1)
                             (#\赚 #t)
                             (#\㽹 #f)
                             (-5 #f)
                             (else -7)))
                          (else
                           (cond
                             (#f #\U000D98B2)
                             (#\U00085B67 #t)
                             (#f #\锳)
                             (-5 #f)
                             (else #\U0002BDAC)))))
                       ((if -1 #\U000521C3 (cond (else 0))) #f)
                       ((cond (else (if #f -2 1)))
                        (if (cond
                              (-9 -35)
                              (1 #\U000F0407)
                              (#\U0008152D #f)
                              (-16 #\U000FB3FE)
                              (#\韄 #f)
                              (#f -8)
                              (else #f))
                            (cond
                              (#t #\윐)
                              (#\U000B5BCB #f)
                              (#t #t)
                              (0 #t)
                              (-3 #\U000C6FDC)
                              (3 #\栠)
                              (#f #f)
                              (#\U000C5D20 #t)
                              (else -3))
                            (- #f)))
                       (else #t))))
                (else -32))
              (let ((v2 #t)) #t)
              #t)
          (char->integer #t))
         (else #t)))
      (#\U00036614
       (let ((v2 (if #t #\U00090814 (let ((w2 #\U000F2539)) #f)))) #t))
      ((if #f
           (cond (else (char->integer #\U001076D3)))
           (let ((p1 #t)) (zero? #t)))
       (zero? -4))
      (#\U0003C5FB (zero? #t))
      ((cond
         (#t (if #f (let ((b1 #f)) #\쀾) #t))
         (#t (let ((e2 (if #f #t #t))) e2))
         (#\を (let ((u2 (cond (#f #f) (else #\U000ECBC8)))) #f))
         ((if (sub1 -3)
              (cond
                (#f #t)
                ((if 4
                     (cond
                       ((cond
                          ((cond
                             (#\탫 #f)
                             (#f #f)
                             (4 #\U0005B481)
                             (#f #t)
                             (#f 0)
                             (#f -4)
                             (else #t))
                           (cond (-7 #f) (#t #\墸) (else #f)))
                          (#t #\U000346D5)
                          ((cond (#f #\퍂) (else #\U00030EA3)) (if #\䰯 #\U000EB7B0 #t))
                          ((integer->char #\U00106777) #\U000D4412)
                          (#t #f)
                          (else
                           (cond
                             (#\U00102F5F #t)
                             (#\璛 #f)
                             (#\U00100BFF #\U000F0EC5)
                             (else 5))))
                        #\U000926FC)
                       (#f -9)
                       ((if (integer->char #\U00070D0D) 6 #t) 4)
                       (else (if (integer? #\U0001908D) #f 3)))
                     #\U000FCADE)
                 #\U0006C213)
                (else
                 (cond
                   (#t #\௶)
                   (#t (abs (abs #f)))
                   (4 #\왣)
                   (#t
                    (if (if #f (cond (else 1)) #f)
                        (cond
                          (#\𥩩 (if #\U000A1FA8 2 -2))
                          ((cond
                             (#\ᣂ #t)
                             (#t #t)
                             (#\修 -3)
                             (#f #f)
                             (-8 #t)
                             (#f #t)
                             (2 #t)
                             (#f #\U000F46DD)
                             (2 #\u2BBA)
                             (else #\쵣))
                           (sub1 #\挬))
                          (else 2))
                        2))
                   ((zero? #t) (add1 #t))
                   (0 (if 4 17 #f))
                   (else #f))))
              #\U00014645)
          (add1 #t))
         ((let ((v0 (boolean? #\U00091015))) #t) #t)
         (#\U000D172C
          (if (if #f #\U00078A09 -3) (char->integer #t) (if #t -1 4)))
         (else #t))
       (if #t
           (char->integer #t)
           (cond
             (#f
              (cond
                (4 2)
                (0 #t)
                (#t #f)
                ((cond
                   ((char->integer #t)
                    (cond
                      (else
                       (cond
                         ((char? #t) #t)
                         ((integer->char -5) (sub1 #t))
                         (#f #\U0005BFB2)
                         (-5 #t)
                         (#\ն #t)
                         (#t (integer? #f))
                         ((sub1 #t) #t)
                         (else #f)))))
                   (#f #f)
                   ((cond
                      (#f (char->integer (if #\ⵐ #t #f)))
                      ((if (cond
                             (#t #f)
                             (#t -1)
                             (#\U000E2C3D #\U000596DA)
                             (#t #f)
                             (#t #f)
                             (#\ᩋ #f)
                             (#\U000E620F #t)
                             (#t #t)
                             (-2 3)
                             (#t #f)
                             (else #f))
                           (cond (-1 #f) (#\U000A44FA -2) (-2 #t) (else #\U00076E38))
                           (cond (else #t)))
                       #t)
                      (else
                       (if (cond (#t #\U0004F227) (-1 #f) (#t -1) (else #f))
                           (cond (#t #f) (else #f))
                           (zero? #\𩓠))))
                    3)
                   (else -2))
                 1)
                ((if (sub1 #t) (cond ((sub1 #t) #t) (else #t)) (if #\ܩ #t #f)) #t)
                (#t #t)
                (2 #t)
                (else -7)))
             (#t #t)
             ((integer->char #t) (if #t #f #\U0006EEAF))
             (4 (integer? #f))
             (else (integer? #t)))))
      (#t (let ((m0 (zero? #\긦))) #f))
      ((- (zero? (cond (#f #f) (else 2)))) #f)
      (#f (let ((k0 #f)) #t))
      (#t #f)
      (#\譴 #t)
      (#f (integer->char (let ((w0 #f)) (- #t))))
      ((char? #f)
       (cond (#t (char? 2)) ((let ((d1 #\跚)) (let ((t1 #\뀿)) #t)) #t) (else 0)))
      ((cond
         ((abs (cond (#f #t) (else 37))) (let ((e2 (cond (3 #t) (else -6)))) 1))
         (#\U000689B1 #f)
         ((cond (else (cond (#f #f) (#\餬 3) (else #\U0010ED8D))))
          (if #f
              (if #t #\貕 #\聣)
              (cond (#\撓 #\U000B1D9F) (#\U000BDB53 2) (2 #t) (else 0))))
         ((cond
            ((if #\慅 #t -1)
             (if (cond
                   ((cond (else #t)) 1)
                   (#\U000F5F12
                    (cond
                      (#\U00066673 #t)
                      (-4 #\═)
                      ((cond
                         (2 (integer? #\U000A73F4))
                         (#f -6)
                         ((- 3) #t)
                         (else (if #f #f -18)))
                       #\U0006A94B)
                      (else #t)))
                   (1 #t)
                   (#\吨 #\傿)
                   (else (integer? #\ᙛ)))
                 #t
                 (cond (else #t))))
            (#t #f)
            ((if #\U0004903B 0 #t) (char->integer #\𝄝))
            ((let ((c1 #t)) #f) #t)
            ((cond (#t #f) (-2 #t) (#f #\U000C6BBE) (else 5)) (let ((p1 #t)) -1))
            (else (let ((c0 #\U00097378)) -1)))
          (cond
            ((integer? #\U000A5364) (char? #t))
            (2 29)
            (#\扥 #f)
            ((cond
               (#f #\U000D60B1)
               (#f #f)
               (#t
                (if (integer->char
                     (cond
                       ((if #f #f #\㛕) #\婥)
                       (#t #\U000F8E04)
                       (#f (cond (#\胵 #\᪵) (else #t)))
                       ((integer->char 5) #\꺀)
                       ((cond
                          (#t 2)
                          (#f #f)
                          (#\U000F1A65 #f)
                          (#t #t)
                          (#\U0007980B #f)
                          (else #f))
                        #f)
                       (else #\U000C348E)))
                    #f
                    (if #t #t (if (zero? #t) #f #t))))
               (#f #t)
               (#t #\黿)
               (#f #\U000B3E4A)
               ((if #t #\U000154C4 (char->integer (boolean? #\ქ))) #\U00105296)
               (#t #\U00106661)
               (#t -16)
               (#f #f)
               (1 #\缺)
               (#\ū #\U000BFF69)
               (else #t))
             (if 4 8 #\U000E8BAF))
            (-2 #f)
            (#\U000550F2 (char->integer 2))
            ((char? #\U0006B1B6)
             (sub1 (cond ((char? #t) #\U0007D2ED) (#f (if -3 0 #f)) (else #t))))
            ((integer? #\너) #t)
            (else #t)))
         (-16 (zero? #\㷲))
         (else -4))
       (if #t #t (add1 #\U0002C0E0)))
      ((cond
         ((if #\昷
              (cond (1 (sub1 -2)) (-2 #\᷇) (#t #f) (#t -4) (else 0))
              (cond (else (if 4 #\U00109EA5 #\㈕))))
          (integer? #\U00101018))
         (#f #\ᡱ)
         ((char->integer #t) #\ᔙ)
         (-9 (if #t -1 #t))
         ((cond
            ((cond
               (#f (cond (#f #\烏) (#\Ⓧ #t) (-2 #\U0008C9BA) (else #f)))
               (else #\ꩇ))
             (cond ((sub1 1) (cond (else #t))) (else #\쪹)))
            (#\U0007839A #t)
            (else (sub1 (if 1 -16 #f))))
          #f)
         (#t (cond ((if (if 2 2 #t) 1 (add1 #\U000C008E)) #t) (else (sub1 -3))))
         (else
          (if (abs #t)
              (cond
                (-2 #\繼)
                ((zero? 8) (if #\U0007E6AA #f #t))
                (2 #\翉)
                (-4 (if #t #\U000BA95B #\焋))
                (#t #t)
                (else #f))
              5)))
       #\U0006A249)
      (#t (abs #\籟))
      (else (integer? #\겘)))
    #\䛹
    #\U000338DB
    #t
    (let ((n1
           (if (add1 #t)
               (cond
                 (#t -2)
                 ((cond ((- #\U00049464) #f) (else #t))
                  (if (cond
                        (1 #\U0004C4E6)
                        (#f -1)
                        (32 -1)
                        (#\U000BE54C #f)
                        (#t #\U000C2C1A)
                        (#f #t)
                        (#\U00075322 #\鮉)
                        (#f -16)
                        (-2 #\U0003CA85)
                        (#t #f)
                        (2 #\ἀ)
                        (#\檜 #t)
                        (#\U00063B24 #\뇑)
                        (#\젶 #t)
                        (#f -1)
                        (-4 #\U00048A3E)
                        (#t #t)
                        (#f #\㇆)
                        (#\᜔ #t)
                        (3 #f)
                        (else 5))
                      #\u0BE4
                      (cond (else #\U0004045B))))
                 (else #\U000B819A))
               3)))
      #f)
    #\实
    (if (cond (else #\蟔)) #t #f)
    #\U000C8914
    1
    #f
    #\U000B2F66
    (let ((b2 -3)) #f)
    (let ((g1
           (if (sub1 #\⸘)
               (cond
                 (4 (let ((q0 #\膃)) q0))
                 ((if #f #t #f) #t)
                 (#\좒 (char->integer #t))
                 ((boolean? (boolean? #f)) #t)
                 ((let ((g0 #\㎩)) #f) (if #f #f #\U0006BC67))
                 ((add1 #t) (let ((t0 #t)) -5))
                 ((if #t
                      (cond
                        ((if #t #f #t) #f)
                        ((if #t -1 (if #\衏 #\U00090FCE #f))
                         (if 64
                             (cond
                               (#f #f)
                               (#\U00055472 (abs #f))
                               ((cond (-2 3) (else #t)) (if 1 #f #\U000D1092))
                               (#f #f)
                               (#f #f)
                               ((if 1 #f #f) #\㜡)
                               ((char->integer #f)
                                (cond (#\߅ #t) (#\U0003FCC3 #t) (else #t)))
                               (11 (integer? #f))
                               (#\蛖 -3)
                               (#f #\⋣)
                               (#\U000756A7 #f)
                               (else #f))
                             (if #f 4 (cond (#f #t) (258 4) (-9 #f) (else #\폙)))))
                        (else
                         (if (if (char? #f)
                                 6
                                 (cond
                                   (#\㪮 4)
                                   (#t #\𣖒)
                                   (#f #f)
                                   (#f #\構)
                                   (#t 2)
                                   (#t #t)
                                   (#f #t)
                                   (-2 #t)
                                   (#t #t)
                                   (#t 2)
                                   (#t #f)
                                   (#t #\U00030667)
                                   (#\˒ #t)
                                   (else #t)))
                             #\吆
                             (if (add1 #f) #\ꠘ (char? #\痴)))))
                      (sub1
                       (cond
                         (else
                          (cond
                            (-4 (cond (#t #f) (else #f)))
                            (#\⪖ #t)
                            ((char->integer -2) -3)
                            ((cond (#t #\U000BB012) (else #\U000ECCB3))
                             (if #\U00070DFA #f #\U00092CB2))
                            (else (cond (#\U000CD0AB #f) (-1 #f) (else #t))))))))
                  #t)
                 ((if 1 2 #t) #t)
                 (else #t))
               #t)))
      (cond
        ((char? (let ((l1 1)) 2)) g1)
        ((if (let ((x0 2)) #t) 1 g1) (char? #\Ỡ))
        ((boolean? (if #t #t #\河))
         (cond
           ((cond (#\U000DB913 #\u200D) (else 9)) (let ((r1 #t)) r1))
           (#f 2)
           (#\U0002CB35 (if -5 #t #\U0001C946))
           ((cond (#f #\u086E) (#t g1) (else #f)) #\㽧)
           (#f (let ((i2 -1)) #f))
           (else (cond (#f #\Ԍ) (g1 -1) (else #\蚴)))))
        (else (let ((g2 #f)) g2))))
    (cond
      ((if #t #f #\U000B16FB) #t)
      (#f #\上)
      (#t (integer->char #\U00102887))
      ((- -2) 1)
      (#\U0005F2E8 #f)
      (else
       (cond
         ((if (cond (#t #\U000A804D) (else #\U000B7E79))
              (let ((c1 #f)) #\䂭)
              #\U00013845)
          #f)
         ((let ((n2 (sub1 #\U0005158D))) (if #t n2 #t)) #t)
         ((integer? 6)
          (if (if #f
                  (cond
                    (#\U000BB63A -2)
                    (1 (if #\㋆ (if #f #t #\襱) #f))
                    ((cond
                       ((if (sub1 #f) (sub1 #\䩸) (add1 #t)) -2)
                       ((cond (1 #f) (-9 (integer->char 8)) (else 7)) #\溺)
                       ((if #f
                            #f
                            (cond
                              (#t #\U00100E37)
                              (#t #\㰖)
                              (#\U000EFAD9 5)
                              (#t #\秺)
                              (#t #\啴)
                              (#t 1)
                              (#\U0007D02E -5)
                              (#\U000D9C2D #f)
                              (1 3)
                              (4 #\蚄)
                              (#t #t)
                              (#f 0)
                              (#f 2)
                              (#f #f)
                              (#t #t)
                              (else #f)))
                        #f)
                       ((if #t 0 #t)
                        (cond
                          (#f (- #\꯴))
                          ((char->integer #f) #f)
                          ((if #t #f #f) 3)
                          ((if #f 8 #\產) (zero? #\U00035BA8))
                          (else 9)))
                       (#f #\࡙)
                       (1 4)
                       (#\铰 #f)
                       (#f (if #t (if #\U000E1255 -1 #\U000643EF) #f))
                       (#\U0010E473 3)
                       ((integer->char (sub1 #t)) (cond (else (boolean? -3))))
                       (#\U000933BC #t)
                       (else #t))
                     (if #f (if #\U000B6052 -3 0) (char->integer #\ᮡ)))
                    (#t #t)
                    ((add1 #t) #\U0006AC10)
                    (else #f))
                  #f)
              #\U0003539D
              #t))
         (3 #t)
         (#t #t)
         (#f (let ((z2 (integer? #\弬))) 1))
         (else -5))))
    #f
    #t
    #f
    (let ((s2
           (if #f
               (cond
                 (-3 (if #t 1 #f))
                 (else
                  (cond
                    ((cond
                       (#t #f)
                       (0 #\𝜄)
                       (#f #f)
                       (-6 #\U0007D1C8)
                       (#t #\治)
                       (#\릨 #f)
                       (4 -7)
                       (#t #t)
                       (7 #\椋)
                       (#\鎭 #t)
                       (#t #t)
                       (#f #t)
                       (-2 #f)
                       (#f #t)
                       (#t -2)
                       (else -1))
                     #\즙)
                    ((cond
                       (#\늡 #f)
                       (-3 #\쉚)
                       (#f #f)
                       (0 #f)
                       (#\U000A03E0 #f)
                       (#\U000A7759 #\U000DE56A)
                       (6 #t)
                       (#\𦮇 1)
                       (#t #\𤣈)
                       (#t #f)
                       (#t 9)
                       (#f #\⥠)
                       (#f #t)
                       (#\U0008C1D5 #f)
                       (#f #\U0007ACE1)
                       (#t 6)
                       (#\U000D7B0E #\𖼋)
                       (#f 6)
                       (128 #t)
                       (4 #\U00080D8D)
                       (#f #\⌓)
                       (#t #t)
                       (else 17))
                     (cond (-1 #t) (#t 1) (#\喾 #\挩) (else #f)))
                    (else
                     (cond
                       (4 #t)
                       (#\胍 #\U0001345E)
                       (-1 #t)
                       (#\㪝 -6)
                       (#\U000AF34F 5)
                       (else #f))))))
               #f)))
      #f)
    #t
    (let ((o0 1))
      (if (abs #\툧)
          #\U000D8AFF
          (cond
            ((cond (#\U00102109 #f) (#\U0003AEBB #f) (#t #t) (-1 #f) (else 1))
             #\篈)
            (#f (if #\U000BE863 7 -1))
            ((let ((c1 o0)) #f) (if #\岦 #t #f))
            ((let ((t2 o0)) -2) (if #t o0 #t))
            (#f (sub1 #\뮚))
            (#t (- 1))
            (#f #f)
            ((char->integer #\U00084147) #t)
            (else 4))))
    (integer? #t)
    (cond
      (#f #f)
      ((if #\U00091B30
           (cond (else (abs 4)))
           (cond
             (#f #f)
             (#t (if -2 #t #f))
             ((if #f #t #f) (char? #t))
             ((cond (else #f)) (if #f #t #t))
             (2
              (cond
                (#f #t)
                (#f #\U000ADF8F)
                (#\U00046BCF -2)
                (#t #f)
                (#t #t)
                (else -2)))
             (#\U000A22CB #t)
             (else (cond (else #t)))))
       (cond
         (#\U000BE7D1 4)
         ((if -1 (cond (else #\㇆)) #t) 2)
         ((if #f #f (cond (#\U00092D5C #\ꛌ) (#\榞 4) (-33 #\𤰖) (else #f))) #\媸)
         (#t -4)
         (-5 #f)
         (#f #f)
         ((- (if #f -2 #t)) #t)
         (#t
          (if (zero? #\u001C)
              (cond
                (#\U000B235E #\龀)
                (#\퇌 #f)
                (#f #f)
                (#\U000419B3 #f)
                (#\旲 3)
                (#\U000FDCE9 #t)
                (else #f))
              (sub1 #f)))
         (else (if #\U00109786 (char->integer #f) #f))))
      ((if (- 3)
           (cond
             (#t 3)
             (#f (if #f #\匛 #\U0003FB97))
             (#f 2)
             ((cond (#t -45) (else #f)) #\U000EDCEB)
             ((if #\Ⰺ -1 2) -4)
             (-1 #f)
             (4 (sub1 #\U000A2381))
             (else #t))
           #f)
       (if #\㇑ (integer->char (- #t)) #\U0007D685))
      ((abs (cond (-2 (zero? #f)) (else (integer->char -5)))) #f)
      ((if #t (zero? 4) #\ꄋ) #f)
      ((cond (else (sub1 (zero? #t)))) (char->integer (cond (else -4))))
      ((if #f #\⒊ #t) 4)
      (#t (cond (else #\u2E5B)))
      (#f -1)
      (else #t))
    (integer->char (if (if #\𨴮 (char? #\U0001EE65) #f) #t #\U00030D7D))
    #t
    (cond
      (else
       (cond
         ((if (cond (#\᳠ #\뻩) (#f #\U00097481) (else #f)) -2 2) #t)
         (#f (if 3 #\褑 (char->integer #t)))
         ((add1 #t)
          (let ((q0
                 (char->integer
                  (abs
                   (cond
                     (#f #t)
                     (#t (boolean? #f))
                     (#\U0003D129 5)
                     (#t #f)
                     (#f (if #t (if #f #\𧁎 #f) (integer->char #f)))
                     (-1 (abs (cond (#\U00057960 #\땤) (0 #t) (else #t))))
                     (else (if #\U000957E5 3 (if 2 1 #\U0005BDF9))))))))
            (if #t #t q0)))
         ((if (add1 (if 1 (- #\抎) #f)) (if #\U000B352F #t 3) #t)
          (char? (char? #t)))
         (else (cond (#t #f) (else 0))))))
    (let ((s1
           (cond
             ((boolean? (char? #t)) #\U000746C6)
             ((cond (else #t)) #f)
             (#t (abs (if #t #f #t)))
             ((zero? 8) #\U000818BA)
             ((char->integer #\U00033576)
              (char->integer (boolean? (if #\뺞 #t #\𥠾))))
             (#f #t)
             (else (integer? #\U000D8932)))))
      (cond
        (#f (cond (else (if -5 #t s1))))
        (#\ॺ
         (cond
           (#\␄
            (cond
              (#f s1)
              (#t #f)
              (#t 1)
              (#\麒 -2)
              (#t 1)
              (#t #\U00100A19)
              (#\U00103CE5 s1)
              (#t s1)
              (else #t)))
           ((let ((v1 4)) #f) #f)
           (else (let ((f1 -6)) #f))))
        (#\U00095625 #\ꇳ)
        ((boolean? #t) (zero? s1))
        ((if #f (if 2 #t #\㬤) (let ((d2 s1)) #f)) (sub1 (let ((u2 s1)) 3)))
        (#\U000F1509 -4)
        (s1
         (cond
           (#f #\箜)
           (#\⭉ #t)
           (1 (let ((g1 #\慘)) #t))
           (#t
            (cond
              (#f #t)
              (#\U00105490 #\U0009096C)
              (#f #t)
              (#t #f)
              (#f #t)
              (else #\ḷ)))
           (#f s1)
           ((cond (s1 #t) (#t -33) (else -2)) -8)
           (s1 s1)
           (#t (cond (else 2)))
           (else #t)))
        ((let ((v2 s1)) v2) #\췖)
        (s1 #\U00086538)
        (else s1)))
    #f
    #f
    (cond
      (5
       (if (cond
             (else
              (if (abs (if (zero? #t) (if #t #t #f) (integer->char #\胴)))
                  #\킈
                  -3)))
           #t
           #f))
      (else #f))
    -3
    (cond
      (1 (if 4 8 #t))
      ((cond
         (#\U000BDCEB #\U000F2428)
         (#f #\U00041C27)
         (#\瘖 #t)
         ((if #f #f #\ꪐ) #f)
         ((boolean? 8) (if #t (integer? #t) #\U00058C96))
         (-2 #t)
         (3 (boolean? (cond (else #t))))
         ((char->integer (sub1 -2)) #f)
         (else #\칵))
       (if #t -1 1))
      (2
       (if (integer->char (cond (-2 #\U00099527) (#t 6) (else -2)))
           (if #\鱉
               (cond (#\㈎ #t) (#t #f) (else #f))
               (cond (#\U000BD5C3 #f) (#\U0009ECB7 #\䵨) (#f #\臛) (else 3)))
           #t))
      ((cond
         ((integer? #f) #t)
         (#\參
          (if (if #\䰂 #f #\U000909C2)
              (cond (#t 2) (2 #f) (#t #\♸) (else 2))
              (integer->char 2)))
         (-8 2)
         ((cond
            (#f (integer->char #\u0D54))
            ((char? #f)
             (cond
               (-4 4)
               (#f #\U000A5DB9)
               (#\U000BD96F #\둦)
               (#t #f)
               (#f #t)
               (#t #\苯)
               (#f -1)
               (#f #t)
               (#t #t)
               (#\䐼 #t)
               (0 #f)
               (#\U000AF1DD #t)
               (#f #t)
               (else 0)))
            (#t #t)
            ((if #\U00047B6F #\U0005DFCF #t) #t)
            (#\U000AC9FC #\U00059442)
            ((sub1 #f) #t)
            ((cond (#\阠 #t) (else -4)) (integer->char 4))
            ((if #t #\㺖 #f) #t)
            (#f (boolean? #t))
            (#f #f)
            (else (char->integer -3)))
          -4)
         (else #f))
       2)
      (4
       (if #t
           #t
           (zero?
            (cond
              (#\u9FF4 #t)
              (#\U000B6454 #\謿)
              (#f -3)
              (4 #t)
              (#f #t)
              (else 9)))))
      ((if (if #f (zero? 0) (abs #t))
           -1
           (cond ((cond (#t #f) (else #f)) #f) ((add1 #t) #f) (else (sub1 #t))))
       (if (if #\䷷ (boolean? #f) (integer? #t)) #\㹥 #t))
      (#t #\U000894DB)
      ((- (if (if #t -4 #f) #f #t)) (- #f))
      (else
       (cond
         (#t (if (cond (else -6)) (if #t #t #t) (zero? #t)))
         (2
          (cond (-2 (sub1 #f)) ((cond (#f #\ꍼ) (else #f)) #t) (#f -2) (else #f)))
         ((abs #t) #t)
         (9 (integer->char (if #t 4 1)))
         ((cond (else (sub1 #\U00033774))) #\U000A5715)
         (#f (zero? (cond (else #f))))
         ((add1 #t) -3)
         (#t (cond (#f #t) (#t #f) (else (if #t #f #\Ȉ))))
         (else (integer? (integer->char #\U0010028C))))))
    (if (boolean? #\윳)
        (abs (boolean? (cond (#\㝜 #t) (else #f))))
        (cond (2 (if -2 #f (- 1))) (else #\U000EAFD5)))
    -2
    (- (zero? #t))
    #f
    #t
    (if (if #\U000A163F (abs #f) #\U000647B7)
        #\U000EF3B3
        (let ((s1 (let ((l0 #\u1BF4)) (integer? #\U000B5B12))))
          (if (if 4 s1 #\U00063F0C) #t (cond (#t #f) (else 4)))))
    (let ((h1 #f)) #f)
    (sub1 2)
    (if #t 33 #t)
    #f
    #t
    #t
    #t
    (char? #f)
    #f
    (let ((c0 2)) (let ((j0 (cond (else #\Ϳ)))) (char? (add1 #\U0001F2B8))))
    #\货
    #t
    1
    #\𧃹
    #f
    #f
    -2
    -2
    (if (boolean? 3) #f (let ((b2 #f)) (- (char? b2))))
    (cond
      ((sub1 (let ((k0 -5)) -1))
       (if (add1
            (cond
              (4 #\랒)
              (#f #\U000CEF9D)
              (-2 #\㋭)
              ((add1
                (cond
                  (#t #\㕋)
                  (-9 #f)
                  (#t (integer? (if 1 #t #\U000ED3F0)))
                  ((if (cond (#f #f) (else #f)) (if #f #f #\腁) #\蔄)
                   (cond
                     ((boolean? #t) (integer? #\U000A34EA))
                     (6 #f)
                     (else #\⇜)))
                  (#f 1)
                  (#t #t)
                  ((if 1 (char? #t) #f) #\U000F4039)
                  (#t (if (if #t #t #f) -1 3))
                  ((cond
                     (#\䝗 (if #t #t 9))
                     (#\枔 -33)
                     ((abs #f) (if #\U0007E74D 3 -1))
                     (else (char->integer #\盱)))
                   #\U000E5596)
                  (else #f)))
               #\U00042214)
              (#f
               (cond
                 ((if (cond
                        ((- #f) (cond (else #t)))
                        (#\U00075DB0 #f)
                        (else (cond (-1 9) (else #t))))
                      (add1 #t)
                      #\裟)
                  #t)
                 ((if 1 (cond (else (cond (else #f)))) (if #t #t 5)) #\좳)
                 (#t 6)
                 (#t 1)
                 (#f #\墎)
                 (#t
                  (cond
                    ((zero?
                      (cond
                        (#f #f)
                        (#f #\U000371E7)
                        (#f #t)
                        (#\꺯 #f)
                        (-3 #\U000BDBAE)
                        (#f -2)
                        (-16 -3)
                        (#f #\䌄)
                        (#t #\𞢹)
                        (#\U000A1B02 #t)
                        (#t 3)
                        (#\U0004F845 #f)
                        (else #\U000F601C)))
                     #t)
                    (#\U000DEA9F
                     (if #t
                         #\U000F61D6
                         (cond
                           (3 #f)
                           (2 -7)
                           (-1 #\鴬)
                           (#\U0007024B #\U0009B599)
                           (#t #f)
                           (#f #\U000579CE)
                           (#\퓀 2)
                           (#f 3)
                           (0 #t)
                           (#t -2)
                           (#t #\ம)
                           (#t -2)
                           (#\U000D12DB #f)
                           (#t #f)
                           (#t -4)
                           (#\U0001C669 #f)
                           (else #\U000C03BF))))
                    ((cond (#\U0002E183 (if -5 #f #t)) (else #t))
                     (cond
                       ((if #\댭 2 #f) #\䔙)
                       ((if #f #f 5)
                        (cond
                          (#\韁 #f)
                          (#t -2)
                          (2 #\𤳱)
                          (#\㧷 3)
                          (#f #f)
                          (#f #\㚶)
                          (-10 -1)
                          (#f #f)
                          (else #\U0009EDD2)))
                       (#t 3)
                       ((if #t 0 2) -1)
                       (else 5)))
                    ((add1
                      (cond
                        (#\푶 #\𧽏)
                        (#f #\U0010D466)
                        (#f #\独)
                        (#t #f)
                        (#t #t)
                        (#t 2)
                        (-2 #t)
                        (else #t)))
                     2)
                    (else (- -2))))
                 (1
                  (cond
                    (#t (if (add1 #\ထ) 4 (abs #t)))
                    ((if #t #f 1)
                     (cond
                       ((if #\U0005B61C 4 #\砯) #t)
                       ((cond (else #f)) -2)
                       (else (cond (#t #t) (-36 #\U0005295B) (#\꼂 #f) (else -6)))))
                    (-1 #t)
                    (#f #t)
                    (#f #t)
                    (#f -2)
                    (#f (abs #t))
                    ((char? (cond (1 #\蟉) (else 3))) #f)
                    ((zero? (if #t 0 #f)) 2)
                    (#\饶 4)
                    (#f #\U00034510)
                    (#t -17)
                    (1 (if #t -1 (zero? #\U00096E08)))
                    (else (integer->char #\唙))))
                 (else #\U000CBFB5)))
              (#f #\U0008B254)
              (#f #\U0009692D)
              (#f #t)
              (#t #\鱆)
              (#t #t)
              (#t #t)
              (#f -4)
              (else -1)))
           (cond (else #f))
           (add1 (let ((x2 #\遊)) #t))))
      (#t #t)
      ((let ((s0
              (cond
                (#\U000C4034 (cond (#\⁛ #f) (else #t)))
                (#\U0006F47E (let ((y1 6)) #f))
                ((sub1 #f) -4)
                (#t #f)
                ((cond (else #\U00057D10)) 2)
                (#f
                 (cond
                   (#f #f)
                   (2 #f)
                   ((if (- (if #\淘 #\U000BED6A #\U0002D122))
                        (char->integer -33)
                        #\ꦝ)
                    #f)
                   (#t #\U000DBF88)
                   (#\U000E3A22 #\頨)
                   (2 #t)
                   (#f -4)
                   (#t 3)
                   (#f -8)
                   (else #f)))
                ((integer->char #t) (cond (#\༡ #t) (else 2)))
                (else #t))))
         #t)
       #t)
      ((if (integer? (if #f -16 2)) -2 -1) #t)
      ((abs #t) -2)
      ((zero? (if #f #f #f)) #f)
      (-1 #f)
      ((if 4 -5 (if #t -4 (boolean? 1))) (if (let ((g1 9)) 1) (if 17 -8 #t) 1))
      ((- #f) 4)
      (else
       (cond
         (#f #f)
         ((sub1 #\羈) #f)
         (#\U0002C2A8 (let ((k1 (char? -1))) #f))
         ((if (if #f
                  #\視
                  (if (cond (else #\ۗ))
                      (if #t (if #\U000173B9 -2 #\U00089529) (boolean? #f))
                      (cond
                        (-1 #f)
                        ((cond (else #\U000BC3CC)) #\U00079916)
                        ((char? -1) (if -3 #\᪃ #f))
                        (#t (sub1 #\U000E7392))
                        (else #t))))
              -4
              #f)
          (let ((t1 (boolean? #\䣲))) (let ((y0 #t)) #t)))
         (#f -3)
         ((integer? #t) #\韋)
         ((cond (#t (if #f #\엏 #\U00084D7A)) (else (if #f #f #t))) #\捽)
         ((char?
           (cond
             ((cond
                (-2 #\儆)
                (-5 -1)
                (#\此 (boolean? #\U000BD7A7))
                (#\ⴜ
                 (cond
                   (#t (zero? #\幑))
                   ((cond
                      ((if -4 #f -9) #t)
                      (#f (char->integer #\溲))
                      (#f (if #\U000EDB8C 15 #\U00089DD2))
                      ((if -2 #\U000BEF76 4) #t)
                      (else #t))
                    (cond (else #\U000C6E1F)))
                   ((cond
                      (#t #f)
                      ((cond (#f #t) (else #t)) (if -1 #\賀 #\㿸))
                      (else #\ህ))
                    16)
                   (else #\싻)))
                (else #t))
              2)
             (#\㣯 #\䤉)
             (#\U000FDAE8 #f)
             (#t #t)
             (-17 #\𫞗)
             (#\U0001F6F7 (cond (else (- #f))))
             (#\U00032983 #t)
             (else #f)))
          (if #t -5 (cond (1 #t) (#f #t) (else #t))))
         (else -2))))
    #f
    (let ((n0 #\U000ED496)) n0)
    #\螳
    #\u9FD2
    #\夔
    #\U00011A2D
    (cond
      ((cond
         ((sub1 #\킸) #t)
         (2 #\U00011E9C)
         ((integer->char #f) #f)
         (#t #\U000392F9)
         ((cond (else (let ((p2 #f)) p2)))
          (if #f
              (char->integer #t)
              (cond
                (#t #f)
                ((if (abs #t)
                     (cond (-2 #f) (else #\逹))
                     (cond
                       (#\䄦 #t)
                       (-4 #f)
                       (#\ꍂ -2)
                       (-1 3)
                       (#t #\狟)
                       (#t #f)
                       (6 #\U000968F9)
                       (#f #\U000904E3)
                       (#t #f)
                       (-1 #f)
                       (-1 #t)
                       (-3 4)
                       (#f #t)
                       (#\U0008E126 -1)
                       (#\谵 #t)
                       (#\U000C2FFC #f)
                       (#t #t)
                       (else #f)))
                 5)
                (#t #t)
                (#f -3)
                ((if #\噾
                     #f
                     (cond
                       (#\U000E1FA1 #\鰌)
                       (#\U00054EB3 1)
                       (#t #\戝)
                       (#t #t)
                       (#t #f)
                       (#t #t)
                       (-1 -1)
                       (-2 #f)
                       (#t #\֍)
                       (-8 #t)
                       (#t 4)
                       (else #f)))
                 (cond (#\U00036776 (char? #\⺱)) (#f (if #\ꙉ #f #f)) (else #\㱞)))
                (else (abs #t)))))
         ((- #f)
          (cond
            ((sub1 #f) #t)
            ((if #\䦧 #t #\˕)
             (if (if #f #f (cond ((cond (else #\⪸)) #f) (else 2))) #\U0009AED5 2))
            ((cond (#t #\⮪) (else -34)) (if #\裶 #\U000DCAA9 #\죧))
            ((if 1
                 -3
                 (if #t
                     (if (cond (#f (if #t #f #f)) (#\U000B42D6 (zero? #f)) (else 2))
                         (if #f (boolean? 2) #\敹)
                         (zero? -1))
                     #f))
             #t)
            (#\錔 #t)
            ((sub1 #\U0008C60E) -1)
            (#\U000E095D #\U000BD6CF)
            (else (- 2))))
         (#\㨆
          (cond
            (#\U001040D0
             (cond
               (1 (- (if #f #\ៃ 5)))
               ((cond (#f -3) (else 0)) #\𪇏)
               ((if (sub1 #\㻈) #\U000CDC2A #t) #f)
               ((if (cond
                      (1 #\ꪌ)
                      (#t 3)
                      (#\U000748D4 #f)
                      (-2 #t)
                      (1 #\u218E)
                      (#t -1)
                      (#t #f)
                      (#\ᔃ 4)
                      (2 1)
                      (#\嬥 -9)
                      (#\旛 #t)
                      (-6 #\U0008AFC5)
                      (1 0)
                      (else #f))
                    #f
                    #\U0005CF8B)
                -2)
               (else #t)))
            (2
             (zero? (cond ((cond (else #f)) #\랥) ((- #f) #f) (#t #t) (else #t))))
            (#f
             (cond
               ((cond
                  ((abs #\U000FD33B)
                   (cond
                     (#\U000857B0 #t)
                     (#f #\U00104B02)
                     (#\❐ -2)
                     (#\༁ #f)
                     (-10 #f)
                     (#t #f)
                     (#f #f)
                     (#\𨽠 0)
                     (else #t)))
                  (else #\䮓))
                #\U00051C14)
               (#f
                (cond
                  (0 (integer? #\U0009C64E))
                  (#t (integer? #\憝))
                  ((if #t #t #t) (if #\⾏ #f #f))
                  (-7 (if -3 8 #\U000FE953))
                  (4 (zero? #t))
                  (else (if #f #f #\U000A30C1))))
               (else (integer->char #t))))
            (else #f)))
         (#t (if (integer->char #\U00109F00) #\U0005D776 #f))
         ((if #\U001016A2 #f #f)
          (let ((b1 #\䔕)) (cond (#f #\蠱) (#\䊤 #\볈) (else b1))))
         (4 (let ((a0 #\U000379BB)) (let ((i0 #\U000EA808)) #t)))
         (#\U000DBDFB (add1 #\U0003F206))
         (#f #\맷)
         ((let ((j1 -2)) #f) #f)
         (#t (if #f #\滺 (zero? #f)))
         (2 (if #f (cond (#\U0005F7C1 #t) (#t #t) (else -4)) #t))
         (-1 #f)
         (-2
          (cond
            (else
             (cond
               (#\ഏ #\휽)
               (#f #f)
               (#\U0007717A #f)
               ((cond
                  ((char? -3) (if -8 (cond (else (if #\U0007236F #t #\ᬽ))) #f))
                  (-16 #\솇)
                  ((if #\흡 #\U0006DAED (if 4 (cond (#t #f) (#f #f) (else #t)) #t))
                   #f)
                  ((if #f #t (cond (else #f))) #t)
                  (#f
                   (cond
                     ((if #t (integer? -1) #f) #f)
                     ((abs #t) 6)
                     (#t (sub1 #\U000CAD5D))
                     (#\讟 #f)
                     (else (if #t (abs #f) (- #f)))))
                  (#t
                   (cond
                     (#t #\⩕)
                     (#\ᯒ #t)
                     (#f (if (if #t #t -7) #f (boolean? #f)))
                     (else #f)))
                  ((cond (else #t)) (zero? #\U000B02E2))
                  ((char->integer #f) #t)
                  (else #t))
                #f)
               (#t -4)
               (#t #f)
               (else (integer->char (char->integer #t)))))))
         (4 -10)
         (else -2))
       -1)
      ((abs #t)
       (cond
         (#\U000B280F
          (cond
            ((cond
               (#t #t)
               (#t #\녻)
               (#t #\ᙵ)
               (11 #\U000DAF80)
               (#\監 #\U00063547)
               (#f 3)
               (else #t))
             #f)
            (#t #\U000BCD91)
            ((if 1 #t #f) (cond (else #\U0008CAEF)))
            (else #\U000C9284)))
         ((cond
            ((cond (#\頱 -1) (#\녜 #f) (else #t)) 8)
            ((let ((q0 #t)) 3) #\摁)
            (1 #t)
            ((integer->char #\ꢑ) #f)
            ((if #f (if (cond (else #f)) 2 #t) #\⋹) (let ((i1 #t)) i1))
            ((integer? 0)
             (cond
               (#\u1A9D (- -1))
               (#t #\U000CD55E)
               (#f (boolean? (if 2 (zero? (add1 -4)) #t)))
               (else #\㾠)))
            ((cond
               (#t -9)
               ((if (add1 #\U00062B21)
                    #f
                    (cond
                      (#t (if (cond (else #f)) #\儂 #f))
                      ((if (cond
                             (#f #\赵)
                             (#f 5)
                             (#\됂 -17)
                             (#t #\숬)
                             (#\梻 #t)
                             (#\𝗳 #t)
                             (else #t))
                           #t
                           #t)
                       (- (- #t)))
                      ((if 1 (cond (else #\U0005D32A)) -1) #t)
                      (#\켗
                       (cond
                         ((cond
                            (#t 3)
                            (#\u2DB7 #\䤽)
                            (#f #t)
                            (#\U00077944 #f)
                            (#f -7)
                            (#t #t)
                            (#\U000BB43B #\츞)
                            (else #t))
                          #\U00030114)
                         (else (char? #\U000C4942))))
                      (#\쫓 (if #f (if #t #f #f) #\U000539D8))
                      ((if (add1 -11) (cond (else #f)) #\遪)
                       (if (if 1 #t #t) #t (if #t 19 #f)))
                      (#t 4)
                      (#f #f)
                      ((cond (#t -3) (-2 2) ((if #\籮 #t #f) #t) (else (sub1 4))) #t)
                      (0 (boolean? #t))
                      ((integer->char #f) (char->integer #\簓))
                      (else (integer? (cond (else #t))))))
                #f)
               (#t #\U000CA86C)
               (#t #f)
               (else -34))
             (let ((y2 #t)) #t))
            ((cond (else #t)) #f)
            (else #f))
          #f)
         ((let ((b1 #\𣤐)) -5)
          (let ((h2
                 (cond
                   ((cond (else 2)) #\괤)
                   (2 #t)
                   (#f #t)
                   (#\ੁ #f)
                   (-2 #f)
                   (#f #\ൽ)
                   (#f -6)
                   (#\U000A092C #\预)
                   (-15 3)
                   (#\U000CD37C #f)
                   ((char->integer #f) -1)
                   (#f #t)
                   (else #\U000C17D2))))
            (if h2 h2 h2)))
         (else #t)))
      ((let ((n1
              (if 0
                  (if (if #\댁 (zero? #t) (cond (#f #\厀) (else #t))) #f #t)
                  (if #t
                      #t
                      (if (cond (#\U00075DDE #f) (else #\❥)) #f (zero? #t))))))
         #t)
       (if #\팈
           (char?
            (if (cond
                  (#\U001033C2 #\ꋸ)
                  (#t #t)
                  (#t -1)
                  (#t #f)
                  (#t #\U000B891D)
                  (#\U0006542D -6)
                  (#t 9)
                  (-1 2)
                  (else #\U000EF4E4))
                #\U00098A3F
                (cond (2 #\U0010AEE8) (#\U000C4CBE #\U000CFB52) (else #t))))
           (zero? (abs #\圗))))
      ((cond
         ((let ((n2 (char->integer #f))) #f) #f)
         (else
          (sub1
           (if (if #f
                   (sub1
                    (cond
                      (#t #\ൊ)
                      (2 #\儍)
                      (#f #t)
                      (#\U0006F827 #t)
                      (#\U0009C27A #f)
                      (else #f)))
                   #t)
               #f
               -6))))
       (if 16 (if 5 (if 3 #\U00093F18 #t) (let ((k1 #t)) 1)) #\𦂏))
      (else #t))
    (if 11 #t (abs #t))
    #t
    -3
    (let ((y1 #\U000942AC)) #t)
    (cond
      (#t #f)
      (-32 (let ((v0 #\嫪)) v0))
      ((cond
         ((if #t (let ((e1 #\U000DCB4C)) #t) (if #f #f 2)) (abs 5))
         (#\ꛟ (let ((t1 #\䃤)) #\U0002DEB4))
         (#t #\U00068536)
         ((let ((q0 (char? #\展))) q0) (let ((v2 #f)) (if 6 #f #t)))
         ((integer->char (let ((r1 4)) #f))
          (if (let ((w1 #f)) w1) (integer? #f) #t))
         ((cond (else (if #t #t #f)))
          (add1
           (if #\U00084139
               (if #t
                   (cond
                     ((abs
                       (cond
                         (-2 #f)
                         (#t #f)
                         (#\U0008F4D2 1)
                         (#\U00043FB7 #\U0004E876)
                         (2 #t)
                         (else -3)))
                      #\U000C8C63)
                     (#f (cond (#t #f) (#t #\U0007FDC7) (else (if #f #\uA7AE #t))))
                     (-7 #t)
                     (#\녦 #f)
                     ((if (if #f 8 #f) #f #f)
                      (cond
                        (else (cond (#\忕 #t) (#t #t) (#\ڣ 1) (else #\U00059871)))))
                     (else (zero? (if -7 #t #\U000C2B37))))
                   (if (cond (else 1))
                       (cond (#t #f) (#\绋 (if #\U00063421 #t #f)) (else #\妨))
                       #t))
               #\塴)))
         ((let ((r2 (add1 #t))) (if #\U0004CE0E 1 #f)) (if #f #\敥 -4))
         (#f (if #t #\𥖖 (let ((j1 #f)) #f)))
         (else (let ((s2 (if #t #f #\U000B17C7))) (boolean? #f))))
       #t)
      (#t -2)
      ((sub1 -2) (cond (-4 #t) (else -4)))
      (#f
       (cond
         (#f #\贃)
         (1 #t)
         (#\U000E3828
          (if #\⨺
              (if -3
                  -9
                  (cond
                    ((boolean? #\സ)
                     (if (integer->char #\u1A9C)
                         (cond (else 1))
                         (zero?
                          (cond (#\U00043B86 -5) (#t #t) (5 #f) (#\⭋ #\諅) (else #f)))))
                    (-4 (add1 (cond (else (cond (else -1))))))
                    ((cond
                       (2 (sub1 #f))
                       ((integer->char (integer? #f)) (if 5 (if #\憉 #t #\uF073) #t))
                       (8 #t)
                       (-1 #f)
                       (else (sub1 #f)))
                     5)
                    (#t #t)
                    ((- (cond ((if #\U000C7852 #f #f) #\ⸯ) (else #\U000548F3)))
                     (if #t #\䲙 (cond ((if #t #t #\ꯎ) #t) (#f 8) (else #f))))
                    ((cond
                       (#\ᶼ (char? -10))
                       ((add1 #t) 4)
                       (#\噽
                        (cond
                          ((- #t) (cond (#f #f) (-3 #\솚) (-1 -1) (#t -5) (else #t)))
                          ((if #f #\খ #t) #f)
                          (#t #\貕)
                          (#t (abs 3))
                          ((sub1 #t) #t)
                          ((if #f #f #f) #\U0004C0C3)
                          (#\U0009BB7F (if #t #t #t))
                          (-1 #f)
                          (#\U00057D06 #t)
                          (1 (- #t))
                          (-5 (zero? #t))
                          (-2 (cond (#t #f) (#f #\U000E56C2) (-2 #t) (#\检 #f) (else 2)))
                          ((sub1 #f) #\U000D9819)
                          (#\U000CA980 (if #\鞢 #f #t))
                          ((cond (else #\婞)) -2)
                          ((cond (#\쪗 -2) (9 #f) (else #\U000C00BF))
                           (cond
                             (#\𢃁 #\𑣣)
                             (#\닯 -10)
                             (#t #f)
                             (#t 4)
                             (#\䪮 #f)
                             (#f #f)
                             (#f -1)
                             (#t #t)
                             (#t #t)
                             (#f #\U0003D520)
                             (#t #f)
                             (else #\U000C0729)))
                          ((cond
                             (#\辤 5)
                             (2 #f)
                             (-1 1)
                             (0 #t)
                             (#\U0003C49F #\䘜)
                             (#t #t)
                             (#f -2)
                             (3 #\㝨)
                             (#f #\庑)
                             (#\ᮈ #f)
                             (#t 1)
                             (2 #t)
                             (else #\偕))
                           (if 7 #\피 #\U00070F70))
                          ((if #t #f -1) (cond (#t #t) (else #t)))
                          ((integer->char #t) (cond (#f #f) (-2 #f) (#t #f) (else #f)))
                          ((cond
                             (#f #f)
                             (#f -1)
                             (#t #f)
                             (#t #\U0009CA5F)
                             (4 1)
                             (-4 1)
                             (else #f))
                           (if -34 #\嚖 8))
                          (else (if #\𠢾 2 #t))))
                       (4 (char->integer (sub1 #f)))
                       (else -9))
                     (integer? 1))
                    (else #t)))
              0))
         (else (integer->char (zero? 5)))))
      (5
       (cond
         (#\艽
          (cond
            (-3
             (if #\닲
                 #f
                 (cond
                   (-3 -1)
                   ((if (- #f) -16 (if (if #f #t #\U000D2410) #f (if #t #\狪 -2)))
                    (if #t #f -2))
                   (#f (if #f (zero? (if #t #f #t)) #\嫈))
                   ((char->integer
                     (cond
                       ((cond
                          (#\U000A762E #f)
                          (1 #\U00080D55)
                          (#\䍏 #t)
                          (#\쏌 #\슒)
                          (else #t))
                        #t)
                       (#t (if 1 #f #t))
                       ((if 2 #\ꂑ 1) (integer->char #f))
                       (else #f)))
                    #\U0004788B)
                   ((- (integer? #t)) -4)
                   (#t #t)
                   ((if (add1 (cond (-4 #\冚) (#\U0009C58E #f) (else #t)))
                        (cond
                          (#f (integer->char #\U000C9147))
                          (#\𩼓 (cond (#\U000A245C -6) (else #t)))
                          (#f (char->integer -20))
                          (#f #t)
                          (else #\U0003C4B0))
                        #t)
                    8)
                   ((abs #t) #t)
                   (else #\ⱡ))))
            (else #\u09BA)))
         (0 (add1 (let ((o1 #t)) #f)))
         (#\쇐 (- #\U000DFA0D))
         ((if (integer->char #f) (let ((a2 #f)) 4) (if 5 -1 #t)) #t)
         ((let ((k0 #f)) k0) (if (add1 #t) -2 (char? #\U000E54AB)))
         (1 (cond (-4 (integer? #\U000F77A3)) (else #\u0ACA)))
         ((if #t
              (if #\U000500CD #\獆 #\U0010F9E5)
              (cond
                (#\U000F0872 #\𢦎)
                (6 #f)
                ((add1 #t) (if #\U0003DCBB (zero? #t) -3))
                (else (if #f (if #t #\U000D4E85 #\U000F84E9) (if #f #\ﻯ #f)))))
          (if (cond
                (9 #\虯)
                (#f #t)
                (#\Ⅰ #\沊)
                (#t #f)
                (0 #t)
                (-18 5)
                (#f #t)
                (#f -2)
                (#\U000C4C4C #t)
                (#t #\U00035458)
                (else #f))
              #t
              #f))
         (#\U00087ACC -1)
         ((if (cond
                ((if (if 5 5 7)
                     (char->integer -1)
                     (cond (#f #f) (else (cond (#t #f) (else -7)))))
                 #\䬾)
                (else 66))
              (char->integer 9)
              (boolean? -2))
          (cond
            ((let ((t2 (cond (#\ꚭ #f) (#\┚ #f) (else -1)))) #\U000E9E06)
             (cond
               (#f #f)
               (#t 3)
               (#\ᴓ #f)
               (#f -4)
               (#f -2)
               (2 -1)
               (else
                (if (if #t #\욂 (sub1 #t))
                    #f
                    (cond
                      ((char? #\U000EDC2B) (if -4 #t 2))
                      (#\ⴴ #t)
                      (#\𨬜
                       (cond
                         (#f
                          (cond
                            (#\④ -3)
                            (#f #\縺)
                            (0 1)
                            (#\쯮 #f)
                            (#\U0010E52A #t)
                            (#t #t)
                            (#t -1)
                            (-5 #t)
                            (#f 2)
                            (#t #t)
                            (#\僈 #t)
                            (6 #f)
                            (-3 #f)
                            (0 #t)
                            (#\U000D46C4 #\U0001714B)
                            (else #t)))
                         (#\疟 (cond (else #f)))
                         ((add1 #t) #f)
                         ((cond (else 2)) (zero? #f))
                         ((zero? -7) (if -2 #t #f))
                         (else #t)))
                      ((add1 (integer? #f)) #t)
                      ((cond
                         ((cond (#\먍 #f) (-5 -7) (-3 -9) (#f #\U0009BC3C) (else -11))
                          (cond
                            (-2 #f)
                            (#t #t)
                            (#f #f)
                            (#\U000867A2 #\ꁗ)
                            (#f #f)
                            (#t #f)
                            (#\𪍝 #t)
                            (4 1)
                            (#f 1)
                            (-2 #f)
                            (#\U0008FC43 #\ዴ)
                            (#t #t)
                            (#f #\U000730C0)
                            (#\U000E96B4 #f)
                            (#f -8)
                            (8 #f)
                            (#t #\U0005EF53)
                            (#\靧 -1)
                            (else #t)))
                         ((char->integer -17) #t)
                         (#f #\쭾)
                         (2 #t)
                         (else #\ᒹ))
                       #t)
                      (#\뭃 (boolean? #\졕))
                      (#t (if #t 16 (integer? #\淣)))
                      (else (zero? #t)))))))
            ((char? #f) #f)
            (#\U00030A3C (char? #\髷))
            (#f (if #\줜 3 #t))
            (else (let ((r0 #f)) #f))))
         ((cond
            ((if #f #f -17) -5)
            ((let ((f2 #\U000DCB6A)) #t) (integer->char #f))
            (2 #\ݍ)
            (else (cond (#f 7) (#f #f) (-1 #\U0003343C) (else #\ຝ))))
          (cond
            (#t #f)
            ((cond (6 #\瑳) (else -10)) #f)
            (#t
             (cond
               (#\U00052364 #\U000C9499)
               (1 -2)
               (#\跫 #t)
               (#f #t)
               (#t -1)
               (#\U000F4753 #t)
               (#\U000F130A
                (if (zero? (if (if #\U000DDA04 -8 8) (integer? #\䓻) #\㩳))
                    (integer->char #f)
                    #t))
               (#f -2)
               (#\U0005F3B8 (if (integer->char #\U000E99CB) #t 1))
               (#t #f)
               (2 #f)
               (4 #t)
               ((if (if (if -9 #\u193C #t) (integer->char #\U00074311) #f)
                    #f
                    (zero? #t))
                (cond
                  ((add1
                    (cond
                      (#\U000178E3 #f)
                      ((integer? #t) 2)
                      ((cond (else #f)) (if #\U0010DEED #\U0004A3BB -8))
                      (-3 #f)
                      ((cond
                         (#\U0002C2E3 -1)
                         (#\U00060040 #\U00069647)
                         (#f #f)
                         (#t #t)
                         (else #t))
                       (sub1 #f))
                      ((cond (#f #t) (else #t)) #t)
                      ((if -1 -1 33) #\U000C4B1F)
                      (else #f)))
                   #f)
                  (else
                   (if #t
                       (cond
                         ((cond (-6 #\뢇) (#f #\U000A532D) (else -5)) -10)
                         (4 #f)
                         (else #t))
                       #\U000421C9))))
               (#t 2)
               (-2 #t)
               (#f #f)
               (#f #\龝)
               (#\U000A0532 #\U000B4EE1)
               (#\椏 #f)
               (#f 2)
               (-2 -4)
               (else #\Ỳ)))
            (3
             (cond
               (#t 1)
               (#t #t)
               (#t #\U0003D47C)
               (#\U000DFF7C -65)
               (#\橏 #\U000FDD06)
               (2 #t)
               (#f #\㱁)
               (else 1)))
            (else (char->integer #f))))
         ((let ((d0 #f)) #f) #f)
         ((if #t (let ((m0 2)) m0) (integer->char (if #\葛 #t #f)))
          (add1
           (cond
             ((cond
                ((cond (4 1) (else #\飫)) 4)
                (#f (- #\U0007FA87))
                (-1 #f)
                ((integer->char #\U000F536D) -3)
                ((if #\晑 2 #t) #\퀻)
                (else (char? #\U000C3C61)))
              (if -1 (integer->char -9) #t))
             (else (abs 0)))))
         (else #\U00051560)))
      (else
       (cond
         ((if (if -4 #t #\U00081E3C)
              (cond ((sub1 #f) #\U00032212) ((if 4 2 (abs 7)) 1) (else #f))
              #\uA632)
          (integer->char
           (if (cond
                 ((cond (#\鬍 #f) (#\ꠔ 1) (#f #t) (else #f)) 1)
                 (#t #t)
                 ((if #\U000328EB -1 -2) (boolean? #\뜺))
                 (else 3))
               #f
               (cond
                 (#\U0009EBB1 #t)
                 (21 (sub1 #f))
                 (#f #f)
                 (else (if #f #t #f))))))
         (else #t))))
    (if (char->integer (let ((x1 (let ((r0 #f)) #t))) x1))
        (if #\U000992D3 (let ((r1 #t)) r1) (integer? 2050))
        (let ((t2 #\U000652DD)) t2))
    (if (let ((e2 1)) (let ((z2 (char? #\蒦))) (if z2 #t #\U00073AD3))) #t -66)
    #f
    (-
     (cond
       ((zero? (cond (#t #\U000DF749) (#t 4) (#t -4) (#f #f) (else -4))) #\㐵)
       ((cond
          (#\U0006CA61 (let ((x0 #\⟟)) 64))
          (#\喒 (char? #\実))
          ((cond (#f #f) (-1 #\둁) (else #\猤)) #\U000F3CDF)
          ((cond
             (2 #\U000712D6)
             (-2 -1)
             (#t
              (cond
                ((char? (if (if #t #f -4) (boolean? #f) #\䧹)) (char? #t))
                (else (boolean? 17))))
             (#t #f)
             (2 #f)
             (else -257))
           #\U0007ED32)
          (#\U000C2124
           (let ((r2 (cond (#t #\𠦴) (#\u9FF8 1) (else #\U000E1CD5)))) #f))
          (else (if #\U000946F2 -3 -1)))
        -1)
       (else #f)))
    (if (sub1 #t) 2 -2)
    #f
    #f
    #\U000E9532
    #f
    -1
    #\U00106A83
    #f
    (if #f 34 #f)
    (cond
      (#\u0D4F #\ꎷ)
      ((cond
         (#t #f)
         (#t #f)
         ((if (cond
                (#t
                 (if #\U00062765
                     0
                     (cond (#t #\ὰ) (#\U00057E66 #t) (-16 #\U000BBEB9) (else 1))))
                (#\聘 #t)
                (#f #f)
                ((char->integer (if #f #f #f)) #t)
                (#\푻 #f)
                (-7 #\U000AE7F9)
                (else -1))
              #f
              #t)
          #t)
         (2 (sub1 (let ((b1 #f)) b1)))
         ((cond
            ((boolean? 3) #f)
            (#f 0)
            ((zero? (if (if #f 8 #t) (zero? #\U000AB0E1) (char? #t))) #\U0006C099)
            ((cond
               (#t #f)
               (2 #f)
               ((cond
                  (-3 (cond (#t #t) (#\賒 -2) (else -2)))
                  (#t (add1 #f))
                  (5 (cond (else #t)))
                  (#\U000E52F3 #f)
                  ((if #\䶣 #\U0008BFFC -8) #\U000E7D31)
                  (#f (cond (#f #\賩) (#\U00064DDF #t) (#t #t) (else #f)))
                  (#t #\U000BC925)
                  (else (integer? #\鹟)))
                #\刕)
               ((if #\U000E5384 (integer? #f) (add1 #\▕)) #t)
               ((if #\U00033CE2 (if #\݄ #f 2) (if #\華 -4 #f)) #\U000A5089)
               (1
                (if #\U000DA41E
                    (cond (#f #f) (#\⌸ 1) (#\蕫 #\U000C00FE) (else #t))
                    (cond (3 #f) (#t 8) (1 #f) (-2 2) (else -1))))
               (-7 #f)
               (1 -16)
               (else #f))
             (if #t (zero? (if 2 #f -1)) (char->integer (integer? -4))))
            (else
             (cond
               (#\썵 #f)
               (#\U0001AB2B (if (if #t #\U00096087 -1) #f (add1 #t)))
               (else (add1 (if #f #t #t))))))
          #t)
         ((sub1 #\U00072EBC) #\Ļ)
         ((cond
            ((cond (-3 #t) (else #f)) -2)
            (#\U000E0CCE (let ((g0 #t)) #t))
            ((if -4
                 #\얃
                 (if (cond
                       (#\᮫ 2)
                       ((add1 #t)
                        (cond
                          ((if #f #\뜽 #t) 5)
                          ((if #\U00012BA3 #f -8) #\౾)
                          (else (integer->char #f))))
                       ((cond (else -1)) #f)
                       (8
                        (cond
                          (#\U00061A22 #t)
                          ((integer->char #f) #f)
                          (#f (if #t #t #t))
                          (else
                           (cond
                             (2 #t)
                             (#f #t)
                             (#t #\U0010D07E)
                             (11 #\U000974FC)
                             (#f #f)
                             (#f #f)
                             (#t #t)
                             (else -8)))))
                       (else (cond (else #f))))
                     -3
                     (integer->char #t)))
             (let ((q0 #t)) q0))
            ((char? #\U000F7B1B) #t)
            ((- #f) (if #t #t #f))
            ((cond (#\㚵 #f) (else -1)) #\䆾)
            (#\U000E7AA3 #\U00017515)
            (else #\Ș))
          2)
         (#\𪵔 #t)
         (else
          (cond
            (#\懘 (if #\U0006505A -4 #f))
            (#\ଶ (let ((g1 #f)) g1))
            (#\U000DFA21 #t)
            (else (let ((x0 #\𠒟)) #\㆚)))))
       -2)
      (#t
       (cond
         (#t 9)
         (#\숳 #t)
         ((cond ((if #f #f -3) #f) (else (boolean? #\U000BCCD2))) #t)
         ((if #\U000477A5 #\羒 #\ᨌ) #t)
         ((if (let ((w2 #f)) w2) #t (if (if #\U000E547F #f #t) #f 8))
          (cond
            ((char->integer 2) #f)
            (#\U000E4340 #t)
            ((-
              (if (if #t #\U0009B8EB #\U000F8471)
                  #t
                  (char->integer
                   (cond
                     (-2 #t)
                     (-2 5)
                     (#t #t)
                     (3 #t)
                     (#t #f)
                     (#\U000B9660 1)
                     (else #f)))))
             (if (cond (0 #\ꓺ) (else (if (add1 #t) #f 7))) #f 1))
            ((cond
               (#t #t)
               (#f -2)
               (#\U000C00DF -1)
               (#t #f)
               (#\U000325BC -5)
               (#\ℱ 2)
               (else -2))
             #f)
            (#t
             (if #f
                 (cond
                   ((if #f 3 #f) #f)
                   ((if #t #\࿒ #t) (add1 #\U0002FCCD))
                   (else
                    (abs
                     (cond
                       (#\皭 (cond (else #\U000F6CBC)))
                       (#t (char? #t))
                       (3 #\鶙)
                       (#\ዲ 2)
                       (else (- #\癀))))))
                 #\㢯))
            (else #t)))
         (#f
          (integer?
           (cond
             ((cond
                ((cond (else #t)) #\u1C9D)
                ((cond
                   (#\U000A22D7 4)
                   ((- #f) (if #t #f #t))
                   (else (cond (#f #t) (3 #f) (2 #\뵔) (#\䢆 #t) (#t #f) (else #t))))
                 (cond (#f #\㺴) (else #f)))
                ((- 0) 0)
                ((integer? 4) (if #f #f (if 1 #f #f)))
                (#f #f)
                (else (cond (else #f))))
              (cond
                (#f #\隽)
                (-21 #\䛺)
                ((- 0) #t)
                (#\Ạ 1)
                ((cond (else #f)) #\в)
                (else #f)))
             (#\U000B15C6
              (cond
                ((cond
                   ((if 0 #\U00091776 #f) -3)
                   (2
                    (cond
                      (#t #\U0002BDEA)
                      (#t #t)
                      (#t #t)
                      (#f -1)
                      (#t #\U0005BEAE)
                      (#f #t)
                      (#\U0006CD79 #f)
                      (#t 16)
                      (#t #t)
                      (-5 #\U000498BF)
                      (#t #\U000B8049)
                      (else #\竓)))
                   (#f (zero? #t))
                   (#f (cond (#t #\U000E07C5) (1 -2) (#\ॖ #t) (else -3)))
                   (#\ꅕ
                    (cond (#f #f) (#\餔 -1) (8 5) (#t #\U0009FC00) (#t 1) (else #f)))
                   (else #t))
                 (if #t 1 #t))
                (else #\㡚)))
             (#f #\U000EF3ED)
             (2 #f)
             ((if #t (if #f (cond (4 -6) (-2 #t) (else -4)) #f) #\ຖ) #\U00076ABF)
             (#t -1)
             (#f (boolean? #f))
             (else (if (- (abs #f)) #t (zero? #f))))))
         (#t #\斠)
         ((if #t (let ((e1 -2)) e1) -6) #\냇)
         (#\U000180FD -6)
         ((if #f
              #t
              (cond
                (#\荏 #t)
                (#\U00067A7C
                 (cond
                   (-1 -16)
                   (else
                    (cond
                      ((zero? 4) (if #\㴅 #\U000B8974 (- #\U0003FC30)))
                      ((cond
                         ((zero? #t) (if #t 1 #f))
                         ((cond (-1 1) (-8 #t) (#t #\퀺) (-2 #f) (#\𐅡 #f) (else #t))
                          (cond (#t #t) (#\U000C6C8F #t) (else #\u1ADC)))
                         ((if #t #t #f) (if 1 -2 #t))
                         (#f (cond (-2 #\U00014632) (else #\U000FC4ED)))
                         ((cond
                            (#f 9)
                            (#t -1)
                            (#\⾙ #t)
                            (#\ᘱ #f)
                            (#t #t)
                            (#f #\U000B1758)
                            (#f 4)
                            (#\௷ -5)
                            (3 #\💁)
                            (-6 #f)
                            (3 #f)
                            (#\齃 #\U0004862D)
                            (#\U000B7D28 #f)
                            (#t -5)
                            (#t #f)
                            (1 #t)
                            (#f #\U0004E279)
                            (else #f))
                          (if #f 66 #\Ⴙ))
                         (#f (sub1 #f))
                         (#f #f)
                         ((sub1 #f) (if #f #\ꆊ #f))
                         (#\䏼 (add1 #\u0B0D))
                         (#f #t)
                         (else (abs #t)))
                       (if (cond (else #t)) #\U000C61F0 -2))
                      (#t (if (cond (#t #\맂) (else #\U0003A952)) #f (cond (else 2))))
                      ((if #t #\༨ (if 4 #f 3))
                       (cond
                         ((cond (#f -2) (else #\U000C5ADC)) #\U00090299)
                         (#f 1)
                         ((cond (#t #t) (else #t)) #f)
                         (#t #\钟)
                         (else (cond (#\U000B921B #t) (else #f)))))
                      (#f #\U0007DA67)
                      (#\U000174D2 (zero? #f))
                      (#f #f)
                      (#\堩 #t)
                      (#f #t)
                      (else (if -2 -17 (if 3 3 3)))))))
                (#\摪 #\U000EDB63)
                (#t
                 (cond
                   ((if #f 1 #t) #\U000135AC)
                   (#\U000B940B #f)
                   ((cond
                      ((- #\젮) #f)
                      (#f #t)
                      ((cond
                         ((abs #\쵥) (if #t #\୭ #f))
                         ((cond (-2 #f) (else #t)) (char->integer #\U0003A94E))
                         (#t 5)
                         ((char? #f) (if #t 1 #\U000993E2))
                         (else 4))
                       (cond (#t (cond (-1 -2) (else #t))) (else #t)))
                      ((abs -6) #f)
                      ((if (if #\눧 1 #t) -2 #\U0008EFB6) #f)
                      ((abs #f) #f)
                      ((integer->char (add1 0)) 4)
                      ((cond
                         (#f (if 4 4 #f))
                         ((char? -130) (integer->char -2))
                         ((cond
                            (#\❘ #\誶)
                            (#\玏 #f)
                            (#t #f)
                            (#f #f)
                            (#f 1)
                            (#f #f)
                            (#t 4)
                            (else -2))
                          #t)
                         ((cond (4 #t) (else 4)) (if #f #f #t))
                         (-8 #\U0008955D)
                         (#t #f)
                         (3 #f)
                         (#\Ѣ #t)
                         (else 9))
                       (- #\u1CB0))
                      ((if #t (if #f #f #t) (if #t #\볱 #f)) 2)
                      (#f (sub1 (zero? #f)))
                      ((char? #\ᖐ) 1)
                      ((cond (else 7)) (integer? 2))
                      (#t 0)
                      (#t
                       (cond
                         ((add1 #f) (if #\U0006CE9C 3 #t))
                         (#t #\揰)
                         (#\U000E2CDF (if -5 #t 5))
                         (#\鉼 (if #\ᮎ #t #t))
                         (#f (- #\嵩))
                         (-1 -64)
                         ((cond (else #f)) #\緟)
                         (else (abs #t))))
                      ((char? 4) #t)
                      (else -3))
                    #t)
                   ((integer? #\U00053015) #f)
                   (else #t)))
                (#\㩬 #t)
                (3 -2)
                (#\蒺 #f)
                (#t #\U001080F1)
                (else 1)))
          (boolean? #t))
         (#t (zero? #\ଋ))
         ((if -32 (if 3 #\튉 #f) (boolean? 17))
          (cond
            ((let ((j0 #f)) #f) (if #\U0005F41C #t #\ꕔ))
            ((cond (else #\U000DB1E5))
             (add1
              (if (cond
                    (#\졬 #\ꤸ)
                    (-5 (sub1 #f))
                    ((cond
                       (#\U000E2134 -3)
                       (1 #t)
                       (#\팊 0)
                       (2 #t)
                       (#f #t)
                       (#\易 #f)
                       (#t #\䠎)
                       (#t #\멦)
                       (#\齳 #f)
                       (#f #\U00099EA8)
                       (#t #t)
                       (#\㎞ #\⍻)
                       (1 #t)
                       (#t #\U)
                       (#\U000CA009 #\U0007AA57)
                       (else -4))
                     (if #t #f #\繣))
                    (#t (cond (#f #f) (else #t)))
                    (else
                     (cond
                       (-2 18)
                       (#\⫓ 1)
                       (-1 #f)
                       (#\U00014CC7 #f)
                       (#\U000B1F63 #t)
                       (#t #\獂)
                       (5 #t)
                       (3 #\鷀)
                       (1 -17)
                       (-1 #t)
                       (else 5))))
                  (cond
                    ((- #t) (if #f #t #\㹉))
                    (-2 (boolean? #\U0006DA00))
                    (#f #f)
                    (#\U0010C277 #t)
                    (#t -1)
                    (#t (cond (else #t)))
                    (else #\U00057D15))
                  #\U00092584)))
            (-8
             (cond
               (2 #f)
               ((cond
                  (1 #\栰)
                  (-16 #\U00092C8F)
                  (else
                   (if (if (cond (-5 #t) (#f 3) (-4 #t) (else #\U000729D1))
                           (cond
                             (3 #t)
                             (-4 #t)
                             (#t #t)
                             (#f #t)
                             (#t #t)
                             (#f #f)
                             (-17 #\U00078735)
                             (else #t))
                           #t)
                       #t
                       #\獯)))
                #t)
               (#t #f)
               ((abs #t) 3)
               (#t #f)
               (#\U000A19C3 5)
               (#t #\U000A4459)
               (#\꒬ #t)
               (#\U000C3BDC #t)
               (#\U0010186B #t)
               (#\U0005F0C6 #t)
               ((if (cond (else (- #f)))
                    #f
                    (if #t
                        (cond (4 #t) (#\騙 #f) (else (zero? #\㟑)))
                        (abs (integer? #f))))
                #t)
               (#t #\U000E1681)
               (#t #t)
               (#t (integer? (if (if (boolean? -2) #t #t) #f 0)))
               ((cond
                  (5
                   (cond
                     ((if (if #f -2 #f) -2 (char? #\쑀)) (cond (else #f)))
                     ((integer->char (if 3 #f #\బ))
                      (if (char->integer -16) #f (sub1 5)))
                     ((cond
                        (35 (cond (#t 16) (-1 #f) (#t #t) (else -2)))
                        (#t 1)
                        (#t -3)
                        (#f -1)
                        (#\U0002DD00 (sub1 #\技))
                        (#\탴 #t)
                        ((cond (#f #f) (else #f)) (if #t #f #f))
                        (else #f))
                      #\噒)
                     (else
                      (abs
                       (cond
                         (-1 #\պ)
                         (#\鉁 #t)
                         (#\U000B7F04 #\U001006AE)
                         (-1 #\綎)
                         (#f 4)
                         (#f -4)
                         (2 #t)
                         (#t #f)
                         (0 #\U00035767)
                         (else 9))))))
                  (else #f))
                #f)
               (#t -3)
               (#t #t)
               (#\儵 #\U00072818)
               (else -4)))
            ((- #f) (cond (else -11)))
            (else (boolean? (cond (#f #f) (1 16) (0 #t) (else #f))))))
         (else (if 2 (let ((t1 #\烾)) 1) -1))))
      (#f 4)
      (#\錜 #t)
      (4 #f)
      ((let ((n0 #t)) #\騇)
       (cond
         (#t
          (cond
            ((cond
               (#\U000D118B (if -3 #t #f))
               ((char? #t) #f)
               ((if 11 #\U0010FE61 #f) (integer? #\U0008E896))
               (else
                (cond
                  (#t #f)
                  (#\츇 #f)
                  (-5 #\U0008747C)
                  (#\U00067570 #f)
                  (-1 #\햑)
                  (-4 #f)
                  (#t #f)
                  (#\㥯 #t)
                  (else #\U00015191))))
             #f)
            (else 3)))
         (-2 -2)
         ((char->integer #f)
          (if (cond
                (#\U0009920F -16)
                ((if #f 1 -6) (add1 #f))
                (#t
                 (cond
                   (#f #\U000F8055)
                   (#\U000F7BF2 #f)
                   (#t #\U000DEA03)
                   (#f #t)
                   (#f #t)
                   (#t #f)
                   (else #\⭓)))
                (else #\鯛))
              -9
              (char->integer #f)))
         ((if (if #f
                  (if -2 0 3)
                  (cond
                    (-3 #f)
                    (#t #\多)
                    (#t #\U00070C5E)
                    (#t #f)
                    (#t #\斺)
                    (#t #t)
                    (#\酩 #f)
                    (else #f)))
              #\U0009DF47
              #f)
          #\⧔)
         (else
          (if (if #\ᝥ #\ӗ #f) #t (if #\U000E5B6C (integer? #f) #\U000474AF)))))
      (else
       (cond
         (1 -5)
         ((let ((h1 #\U00048519)) (let ((n0 #t)) #t)) #\邖)
         ((cond
            ((cond (#t -3) (#t #f) (#\壙 #\U00059B41) (#\曈 #f) (else #t)) #t)
            ((cond (else #\U0010A109)) (if #f #\U0005FD3C #t))
            ((cond
               (-1 -4)
               (3 #\䟹)
               (#t #\뿛)
               (2 #\U0009B338)
               (-7 #t)
               ((if (integer->char #f)
                    (if (cond
                          ((cond (-128 #f) (else #f)) #t)
                          ((char? -2) (add1 #t))
                          (#t -1)
                          ((char->integer -3) -2)
                          ((sub1 #f) (zero? #\U000BE95F))
                          ((integer->char #\텅) #t)
                          (else
                           (cond
                             (1 #\U00050875)
                             (#f #t)
                             (-5 -15)
                             (#\U0009164A 2)
                             (#f #t)
                             (else 3))))
                        2
                        (boolean? (cond (else #f))))
                    #f)
                #\雜)
               (5 #\u0E7E)
               (#f -8)
               (#t #\#)
               (else 3))
             (if #t #\U00089B3B #t))
            ((if #\喕 #f -1)
             (cond (1 #f) (#f 0) (#\幋 #\ᢿ) (#t #f) (8 #t) (else 19)))
            (else (let ((c0 #t)) #t)))
          -3)
         (#t (cond (else (add1 #f))))
         ((cond
            (1
             (cond
               (3 #t)
               (-3 #t)
               (-1 #\U0001B25B)
               ((cond
                  (#t
                   (cond
                     ((add1 (sub1 #f)) #t)
                     (#f (char->integer (if #\꒻ 1 #\홠)))
                     (#\礜 #t)
                     (else #t)))
                  ((cond
                     (-1 -1)
                     ((cond
                        ((if #t -4 #\噉) (char? #t))
                        (#\䧼 (if #t #\U00059C98 -2))
                        (#\藃 -2)
                        (#t 4)
                        ((cond
                           (1 -1)
                           (2 #\U000D5A0F)
                           (-32 #f)
                           (#f #\땅)
                           (#\U0009D7C6 3)
                           (#t #\풑)
                           (#\U000EE939 #t)
                           (#f #t)
                           (4 #f)
                           (else 1))
                         #f)
                        (1 (if #f #t #t))
                        ((if #t -2 #f) (boolean? #t))
                        (#t 16)
                        (#\䄻 #t)
                        ((sub1 -3) #\ꢞ)
                        ((cond (else -2)) #f)
                        (#f #f)
                        ((cond
                           (#f #\䴯)
                           (#\U000EF3B8 #f)
                           (#t 1)
                           (#t #f)
                           (#f #\㜩)
                           (#t #\ⶶ)
                           (#f -2)
                           (-2 -3)
                           (0 #\旳)
                           (#f 4)
                           (#f #t)
                           (#f #t)
                           (#t #\呒)
                           (else #\妝))
                         (cond (#t #\ý) (65 #\uAB63) (1 #\uE598) (#t -2) (else #t)))
                        (else (boolean? #\U000FD0A8)))
                      (integer->char (char->integer #t)))
                     (#\U000D415E (if 0 #\U00050FC0 #\돣))
                     (#t #t)
                     (0 3)
                     (#t (add1 (cond (else #\U0006A3AD))))
                     (else #f))
                   #\˼)
                  (#\U00034A5E #\U0007A9D7)
                  (#t (if #\᪩ (integer->char 5) (integer->char #t)))
                  (#t #\㞾)
                  ((if #\U00108DFE (abs #\쇭) #t)
                   (if #f
                       (cond (#\U00053580 -6) (else -5))
                       (if (cond (-1 #t) (else #t)) #f (if #\U000951A7 -1 #f))))
                  ((if #\U001074EB
                       (cond (#t (cond (#f #f) (else #f))) (else (cond (else #t))))
                       #t)
                   #\U000C34E0)
                  (else #f))
                #f)
               (else
                (cond
                  ((cond
                     (#t #t)
                     (#f (- 6))
                     (#\U000ADED2 (if (if #f -4 4) #t (if #f 4 -2)))
                     ((if #\U000E809E (char? -2) #\뼿) -5)
                     ((if 3 #t 1) (cond (else #f)))
                     (#t #f)
                     ((char->integer #f) -2)
                     ((if (- #\空) #\U0006C878 (boolean? #\웋)) #\췴)
                     (-2 -5)
                     (#t #\썒)
                     (else (sub1 2)))
                   #t)
                  (#t (if #f #f #t))
                  (else #\⌜)))))
            (else #\ퟗ))
          (if (if 1 #\Ⱨ #\U00075B2A) #\稧 (if -8 #\癅 #t)))
         (#f (if -2 (let ((r0 #f)) r0) #f))
         ((let ((r1 #f)) 1)
          (cond
            ((cond (#t #\⇣) (else #f)) #f)
            ((if #\떤 #\摦 #t)
             (if #f
                 (boolean?
                  (if (if (cond
                            (#f #\U00030944)
                            (#\U0001F99F #t)
                            (#f #\棟)
                            (#f #f)
                            (4 4)
                            (3 -1)
                            (#t 33)
                            (#\U0009468A 1)
                            (5 #f)
                            (-2 #f)
                            (-4 #f)
                            (#f #\ᖾ)
                            (#t #f)
                            (-2 #t)
                            (#f -2)
                            (0 5)
                            (0 #\৲)
                            (#f #f)
                            (#t #t)
                            (else #t))
                          #\U0008A79F
                          (if #t #f #t))
                      (add1
                       (cond
                         (#f #t)
                         (#\ӷ #f)
                         (#f #\ᣢ)
                         (2 #\U0004E2CE)
                         (#\弶 #\火)
                         (#t #f)
                         (else 1)))
                      5))
                 #f))
            ((abs
              (cond
                ((cond (else #f)) #f)
                (#f 3)
                ((if (cond
                       (#\ꁇ #\U00067CF0)
                       ((cond
                          (#f -1)
                          (#\U0003D76E 3)
                          (#\u088E #t)
                          (else #\U0007099D))
                        (if #\珹 #\U000BAFF5 #\牅))
                       (else #t))
                     #\U00084B1F
                     #t)
                 (cond
                   (#t #f)
                   (1 (zero? 3))
                   ((- #f) #f)
                   (#f
                    (cond
                      (else
                       (cond
                         (#t #t)
                         (#\彧 #f)
                         (#\U000D6BCD #t)
                         (#f #f)
                         (#f #f)
                         (#t 7)
                         (#\U0006CDE4 -1)
                         (#t -5)
                         (0 5)
                         (-2 #f)
                         (#t #\U000DD342)
                         (1 -4)
                         (#\Ը #f)
                         (else #t)))))
                   (#t #f)
                   ((integer->char #\숮) (integer? -2))
                   (#f #\諑)
                   ((cond
                      (#t #\U00050840)
                      ((integer->char #\욫) #t)
                      ((cond (3 #f) (2 #\耂) (#f 1) (-2 #\뢫) (else #f)) (boolean? 5))
                      (#f #f)
                      ((boolean? #t) #f)
                      (-2 (if -3 -1 #\u0530))
                      (else #\U000C5286))
                    (- (if #f #f #\횅)))
                   (-2 -5)
                   (#t #\U00089C32)
                   ((abs (boolean? #\U000D7895)) #f)
                   (#\蟓 #\轠)
                   ((if #f #t 2) #f)
                   ((integer->char #t) #\U000A1CD4)
                   (#\꺰 (zero? -2))
                   (#f #f)
                   ((if #\娄 (cond (#t #t) (20 1) (else 1)) #t) #f)
                   ((char->integer #f) #t)
                   ((cond
                      ((sub1 #t) #\㡫)
                      ((- #f) #f)
                      (#\U0003ECE6
                       (cond
                         (#f #t)
                         (#t #\U000E49E9)
                         (#f #\U0003E96B)
                         (#f #f)
                         (#t #t)
                         (#\𢅨 #\U000C5A05)
                         (#t #\쬡)
                         (-3 #\U000C16CB)
                         (#t #f)
                         (#f #t)
                         (-11 #t)
                         (#\U000F89DA 5)
                         (#t #\蹼)
                         (else #\𠵞)))
                      (else #f))
                    (cond
                      (#t #t)
                      (else
                       (cond
                         (-2 #\U000888F9)
                         (0 #t)
                         (#f #t)
                         (#f #t)
                         (2 #t)
                         (#f #\䥞)
                         (-10 #\U00079FB7)
                         (#t #\鹈)
                         (else -2)))))
                   ((cond
                      (else
                       (cond
                         (#t -2)
                         (#f #\月)
                         (#f #\U000C14FF)
                         (1 #t)
                         (-3 #t)
                         (#t 2)
                         (#f #f)
                         (4 #t)
                         (1 #t)
                         (3 2)
                         (#\㪂 #f)
                         (#\u0D53 #t)
                         (else -2))))
                    (cond ((if 8 32 #f) #f) (else (if #t #t #t))))
                   (-3 5)
                   ((cond
                      (#f #\U00053FCB)
                      ((if #t #f 1) #t)
                      ((char->integer #f) #f)
                      (#f -2)
                      (else #f))
                    (add1 -1))
                   (else #t)))
                (else 7)))
             #f)
            ((cond (#t #t) (else 5)) #f)
            (#f -1)
            (#\U00047DF6 -3)
            (else #f)))
         ((cond
            (35 #f)
            (#f #t)
            (#f (let ((p0 1)) p0))
            (#t (integer? #f))
            ((abs -32) (if 2 -1 #t))
            (else 32))
          (cond ((let ((n0 #t)) #t) #\u2428) (else -1)))
         (68
          (cond
            (#t (abs #t))
            (#f (let ((x0 #f)) #t))
            (#f #f)
            ((cond
               (#\奐 #t)
               (#\U0008D98C #t)
               (#\U000E6881 -1)
               (#f #f)
               (else #\U000E2B28))
             #f)
            ((cond
               (#\䇍 -2)
               (#f #\U000640CB)
               (#\掠 #\U0002FF4F)
               (#\𓊧 #f)
               (#f #t)
               (#t #\U000EDFCC)
               (else #t))
             (cond (else 3)))
            (else #f)))
         ((integer->char (char->integer #\杄))
          (cond
            (#\U000141F0 #f)
            ((abs #t) (if #t -4 #\U000AD0AB))
            ((zero? 1) (if -1 4 (char? (if #t #t -4))))
            (3
             (cond
               (4 -3)
               (#f 8)
               ((if (if (sub1 #\啛) (cond (else #f)) #t) (cond (else #t)) #f) #f)
               (#\赑
                (cond
                  ((cond
                     ((if #t #\U000EEE9C #\U00072671) -1)
                     ((cond (else #t)) (if #f #f #\U0010D709))
                     (5 (cond (#\ආ 4) (else -2)))
                     (-5 #t)
                     (else (cond (else -3))))
                   (cond
                     (else
                      (cond
                        (#\⚽ 2)
                        (#\挚 #f)
                        (#f #f)
                        (#f 0)
                        (#\U000D21FF #f)
                        (#f -3)
                        (#t #t)
                        (#f 4)
                        (else -5)))))
                  ((cond
                     (#t (cond (else #f)))
                     (#t (boolean? #\U00014869))
                     (else #\㭖))
                   #f)
                  (else (cond (else #t)))))
               ((char? (cond (else #t))) 5)
               ((if #\鷥
                    (if (char->integer #f)
                        (cond (16 #f) (#f #f) (#f #t) (else #\롦))
                        (sub1 #f))
                    (cond
                      ((add1 #f) #\U0007B77E)
                      ((abs -2) #\U00109120)
                      ((integer->char #\U000B43DB) (sub1 #f))
                      ((cond (#f #f) (#\U000FEF28 #\墥) (else -1))
                       (cond
                         (#t #f)
                         (2 #f)
                         (3 #f)
                         (#f -3)
                         (4 #t)
                         (0 -3)
                         (#t -1)
                         (else #t)))
                      ((cond
                         (-2 #f)
                         (#\⮎ #f)
                         (5 #\U000F27A9)
                         (#\U000BA164 #t)
                         (#\岏 1)
                         (else #\U00104CAE))
                       (if #t 1 #t))
                      (#f (if #\U001007BA #f #\U000F82CF))
                      (1 (cond (#\U000117A6 #\U000C44C1) (else #\U000C55F8)))
                      (else (if #t #t #\畺))))
                (if #t
                    #f
                    (if (cond
                          (#f -4)
                          (1 #\䋙)
                          (#t #f)
                          (#f #\U00037900)
                          (#\U000D3F2D #\鰂)
                          (#t 4)
                          (#t #\భ)
                          (1 #\跦)
                          (else #f))
                        3
                        #f)))
               (#t -3)
               (else #t)))
            (#t #\U00072614)
            (5 (if -2 #t #t))
            (#t (let ((t2 -1)) #t))
            (else (let ((h0 #f)) h0))))
         (else #\U000E125C))))
    (if #f #f #\Ⳙ)
    #f
    #\U00102A7F
    #\쳣
    (if #\녋
        (cond
          ((if (cond
                 ((zero? 4)
                  (if (cond (-4 #t) (else #t)) (if #\U0007371A (sub1 #t) #f) #\⚻))
                 (-2 3)
                 (#\U000A869F -1)
                 ((cond
                    ((if (cond
                           (#t #t)
                           (1 #f)
                           (#t #f)
                           (#f 2)
                           (#f #f)
                           (#f #t)
                           (#f #f)
                           (#t #\ܻ)
                           (#\U0005575E #t)
                           (else #t))
                         #t
                         (if #t #f #f))
                     #f)
                    (else (boolean? #t)))
                  -8)
                 ((if #\촛 4 (add1 #f)) #f)
                 (else #\U0002C596))
               (integer? #f)
               -8)
           #\U000547C3)
          (else #t))
        #t)
    #t
    (if (add1 (abs #f)) (let ((w0 #t)) #t) 0)
    #t
    (integer->char #t)
    #t
    (if (cond
          (#f (let ((j0 #t)) #t))
          ((abs (let ((z1 #t)) -1)) #\U00087168)
          ((cond
             (else
              (cond
                (#f #f)
                (#f #f)
                (#f #t)
                (#t #\ꏯ)
                ((if #\U000A0DD1
                     (if (if #f #f (char->integer #t)) #f #t)
                     (if #f
                         (if #t (if #t #f #f) (cond (#f #f) (-1 #t) (else -1)))
                         #\U0007D10E))
                 #t)
                (-5 #t)
                (#\U000DF2DE -17)
                (#f #\᾽)
                (-5 #t)
                (#f #t)
                (#t -16)
                (#f #\U000A2289)
                (-1 #t)
                (else #\U0001F7ED))))
           #t)
          ((cond
             ((let ((o1 #t)) #\껸) #\죔)
             (#f -5)
             (#f (if #\U0007A1E1 3 (- #t)))
             (-3 #\澥)
             ((cond (#\U000B9059 (if #t #t 4)) (else #\蜥))
              (boolean? #\U0009081B))
             ((abs #f) #\U00096917)
             (else #\䤠))
           (cond (else 2)))
          ((let ((z1 2)) #\Ꜩ) (add1 (abs #\U0006C24D)))
          ((if (let ((o2 #t)) #f) #\㾴 #t)
           (cond ((let ((u0 2)) u0) #t) (else #t)))
          ((char? #\ꏮ) (cond (#f (if #f 2 0)) (#\U0007C83F #f) (else #t)))
          (else (char? #\ὠ)))
        (if #t
            (if (if #t 4 #\쥣) #f #f)
            (if #\ꡦ -3 (cond (else (if #t #\U00069F1C #\U000DB1F4)))))
        (char->integer (integer->char (- #\U000C5E0D))))
    #f
    (cond
      (#t -2)
      (#\U00076AD5 #\㣱)
      (#\U0001E7F2 (if 4 (if #\U000726F5 #f #f) #t))
      ((cond
         (#f -2)
         (-1
          (cond
            ((if -4 #f #f) (integer? -5))
            (#\븾 (char->integer #\U000AED73))
            (4 2)
            (else #f)))
         (else -4))
       (if #\U0003A198 5 2))
      (else #\U0006F496))
    #f
    -1
    #f
    (cond (else #\U0004CB87))
    (add1 (sub1 #t))
    #\U00101A95
    (sub1
     (cond
       ((cond (#t (abs -1)) (else (let ((h1 #t)) #\U00036343))) (if #f #t #\𠱅))
       (#\杷 #t)
       (#f
        (cond
          ((cond
             (1 #f)
             (#f 0)
             (-2 #t)
             (#t #f)
             (#f 8)
             ((cond
                (#t #f)
                ((abs (integer->char #f)) #t)
                (#\U000DD112 (integer? -1))
                (-1 #t)
                (else #t))
              -4)
             (#\U0010A2E3 (boolean? (if (boolean? (integer? -3)) #\U0001C88F #f)))
             (else -8))
           (cond (2 (abs (zero? #t))) (else #t)))
          (#\ﮅ #t)
          (#t (cond (2 #f) (#t #f) (#f #f) (#f #t) (#\蓊 #f) (else #f)))
          (else (if #\U00107E9B #\U0003A51E #t))))
       (#t #f)
       ((let ((o1 (char? 32))) (if #t -1 #f))
        (cond
          ((sub1 #t) (let ((i0 #t)) #f))
          (#\☇ #f)
          ((zero?
            (cond
              (#f
               (cond
                 (#t #\睲)
                 (#t (if #\U0004E959 #\U001047CC #t))
                 (#t #f)
                 (else 0)))
              (#t
               (cond
                 (#f #f)
                 ((cond (else #t)) #f)
                 (#t (if #f 8 #t))
                 ((- #\U000E0421) (if #f #t #f))
                 (else (if #f -1 #f))))
              ((abs #f) 4)
              (else (if (boolean? #\U000E9F2A) (if -2 #t #\蕫) #f))))
           #f)
          ((cond
             (#\U0009E041
              (cond
                ((if (char->integer 66) #t #t) #f)
                ((abs #\𥕮) #t)
                (1 (if #t #t (cond (else 1))))
                (#f 11)
                (#\쭧 #\㒜)
                (#\uA48E (boolean? (cond (#t -3) (#\ᛑ 1) (else #f))))
                ((sub1 #t) 6)
                (else
                 (cond
                   (#f (if #t #f #t))
                   (8 2)
                   (#t #t)
                   (-3 (if #f -3 #t))
                   ((add1 #f) #t)
                   (1 -2)
                   (else -1)))))
             ((add1 #\⃧) (if #f #\쨞 #t))
             (-2 -2)
             ((char? (if #\U0008AB8B (if #f #\U0009896A #f) (char->integer #t)))
              -5)
             (-3 #\U000AF406)
             (4 (cond (2 #t) (#\U000670A5 (char? 2)) (#\셨 #\U000BFDD6) (else #t)))
             (#f #f)
             (else (char? (sub1 (char->integer #t)))))
           #f)
          ((cond
             (#t -1)
             (#\㫋 #\U000AF47E)
             ((cond
                (else
                 (cond
                   ((if (if #f #t #f)
                        (cond
                          (#t 0)
                          (#t -2)
                          (#f #\U000998EA)
                          (0 #f)
                          (-3 #\㳡)
                          (else #\㹗))
                        -4)
                    #f)
                   (#t
                    (if (cond (#f #f) (#t #t) (else #\U00080275))
                        #\𐆗
                        (if #t #f -1)))
                   ((char->integer -2) #\U00044823)
                   (else (if -67 (cond (-5 #f) (else #\U0001620A)) #\U000362F3)))))
              #\U00077FE7)
             (#\U000C3F21 3)
             (#\퐶 2)
             (else #t))
           #f)
          (#\ᕖ
           (cond
             ((sub1 #t) #t)
             (else
              (char?
               (cond
                 (#\ᡱ 4)
                 (#t
                  (cond
                    (-2 #f)
                    (#\恛 #t)
                    (#f #\U00037966)
                    (#\U0007DC17 -8)
                    (2 #t)
                    (#t -1)
                    (4 #\듄)
                    (#f 5)
                    (#t #t)
                    (else #t)))
                 ((if #t #t #f) #t)
                 ((if #f -1 #t) (cond (#t 2) (else #f)))
                 (#\锑 #\U00109474)
                 ((sub1 -1) #\U00105560)
                 ((if #\U000A0CCF -1 -5) #f)
                 (else -3))))))
          (else (let ((u1 #t)) -1))))
       ((if -1 (add1 4) #t) (let ((q0 #t)) (let ((x1 -69)) #t)))
       ((cond (-1 #\U000A5814) (else (integer->char #f)))
        (cond
          (#f (if #t #\U00052B22 1))
          ((abs #t) (integer->char #t))
          (else (cond (#t 4) (#t #f) (else #\큖)))))
       (#t -2)
       (1 #f)
       (else (char? #t))))
    (let ((y2 (boolean? (let ((e1 #t)) (cond (else e1))))))
      (let ((a2 (cond (#t (if #\兀 y2 4)) (else #\둝)))) a2))
    (sub1
     (if #f
         #\糙
         (if #t
             (cond (#f #t) (#\𢷖 #f) (0 #\U000EE61A) (#t (boolean? -2)) (else #\㾊))
             8)))
    -6
    #f
    (if -1 (cond (else #\觌)) #f)
    (if (let ((t0 (char->integer (if #\쟎 #f #t)))) #\깴)
        (if (boolean? #f)
            (cond
              (1
               (cond
                 (#f 1)
                 (#f #\U0009D060)
                 (4096 #f)
                 (#f #\u0EE1)
                 (#t 0)
                 (-16 #f)
                 (-3 -4)
                 ((if (if #f
                          3
                          (if (sub1 8)
                              (cond
                                (3 #\U0005E23E)
                                (#t #t)
                                (#f #\U000DDBDF)
                                (-16 #t)
                                (#\U000F9CDF -6)
                                (else -2))
                              (char->integer 3)))
                      (integer->char -3)
                      -2)
                  #t)
                 (-3 #f)
                 (#f 2)
                 (else #\ᮇ)))
              ((if (abs (- (if (if #t #\蒩 -10) (if #t #\U000E4586 #t) #t)))
                   (if 11 #\U000C64D9 (add1 #\魱))
                   2)
               (add1 2))
              (#f (boolean? #f))
              (#t #t)
              ((cond (else #f)) #f)
              (#f -1)
              ((let ((o0 #\ఇ)) #t) #\U000A2CCE)
              (else (if #f 1 #\U000790BB)))
            (cond
              (#t (cond (#t 2) (#t #\蠉) (else #t)))
              (#t #\U00070A99)
              (#f #t)
              (#f
               (if #f
                   (cond
                     (#t
                      (if (cond
                            ((cond
                               (1 #f)
                               (-4 #t)
                               (#f #\詅)
                               (#\U000DB158 #f)
                               (#f #t)
                               (#t #\脈)
                               (#t #t)
                               (#t #t)
                               (#t #\뭏)
                               (#t -4)
                               (#t #f)
                               (#f #f)
                               (#\𢙈 #t)
                               (#f #\U000EB85D)
                               (else #\譔))
                             #\U000342E8)
                            ((cond (#f 4) (else #\U000EBCC0)) #t)
                            (else #f))
                          #t
                          #t))
                     ((cond (else #\遤)) #f)
                     (3 -6)
                     (9 2)
                     (else #t))
                   #\U0004802E))
              (6 #\U000B85EA)
              (8 (boolean? #f))
              (else #t)))
        (cond (else #f)))
    (integer? #\뻠)
    (let ((s2
           (let ((z2
                  (cond
                    (#f #f)
                    ((char->integer #\ً) -8)
                    (-1 -1)
                    (#\閧 (integer? #t))
                    (#t (if #t -1 #\爿))
                    (#\킑 #t)
                    (#\ڰ #t)
                    (-8 (let ((q2 #\ꋛ)) -1))
                    (#f 16)
                    (else (add1 (char? #t))))))
             (integer->char #\↸))))
      #t)
    #t
    (if #\٘ (integer->char #f) (let ((c1 #\U0006708B)) c1))
    (cond (else 2))
    2
    (char->integer (- 1))
    (if #\U0005131E #f #t)
    (cond
      ((if (cond
             (#f -4)
             (#\뫹 #\U00067CBD)
             (#\踩 (if #f -1 3))
             (#f (cond (else #t)))
             ((- 4) (let ((p1 #\U000D7914)) #f))
             (1 (if #f #t #f))
             (3 #\砭)
             ((let ((w0 #\U00094DBF)) -10) (let ((b0 3)) #\䎫))
             (#t #f)
             ((if #f #t #t)
              (cond
                (2 #\텟)
                (#t #t)
                ((cond
                   ((cond
                      ((char->integer #t) #t)
                      ((if #t #\ꣁ (cond (else #\U0006D609))) (if #\㳏 #\姱 2))
                      ((if #\策 (abs -2) #t) -3)
                      ((cond
                         ((- #\U00079659)
                          (cond
                            (#t #t)
                            (#t -5)
                            (#f #t)
                            (#\U00062A23 11)
                            (#\U00051031 #\执)
                            (#t #f)
                            (else #t)))
                         (#f
                          (cond
                            (#t #t)
                            (-8 #\땖)
                            (#t #t)
                            (#\갩 #\U0007D89C)
                            (#f 2)
                            (-1 -2)
                            (#f 2)
                            (else #f)))
                         (else 1))
                       (cond
                         ((cond
                            (#t #\ꬄ)
                            (1 3)
                            (#\哢 #\猜)
                            (-3 #f)
                            (#t #\uAA38)
                            (#t #f)
                            (-4 6)
                            (#t #f)
                            (#t 1)
                            (#\鑄 #f)
                            (#f #\U000DE732)
                            (#t #t)
                            (else #f))
                          #t)
                         ((if #t #\➂ #\誱) #f)
                         (#\텲 (cond (3 #f) (else 8)))
                         ((cond (#\U000D1DB8 #f) (#t #f) (-4 #\艦) (else #\祝))
                          (if #t #\肠 #t))
                         (#t 2)
                         (#\霽 (cond (else #\偓)))
                         (#\𑁇 #\ⷃ)
                         (#\U00055D07 (boolean? -3))
                         (#t (abs 2))
                         (-4 #t)
                         ((cond
                            (#t #\冯)
                            (#t #t)
                            (#\U000DE72B #\蓛)
                            (-1 #f)
                            (2 #t)
                            (else 3))
                          (char? #\U000B0D11))
                         ((if -2 #t #t) (if -2 #\遛 #\U00075318))
                         (else #\投)))
                      (else -1))
                    (integer->char #\옟))
                   ((if #f
                        #\U00017B45
                        (cond
                          ((cond
                             (-1 #f)
                             (#\𦇐 #t)
                             (#\㜥 #\銌)
                             (#t -5)
                             (#\여 1)
                             (#\U000FC685 #f)
                             (else #\垵))
                           (if #f -1 #\೩))
                          (7 -4)
                          (#f #f)
                          (else 4)))
                    (if 4 (integer->char (cond (#\U0004845E #f) (else #\𧞠))) #t))
                   ((cond
                      ((if #t
                           (cond
                             (#\᷃ #f)
                             (#f #t)
                             (-8 -2)
                             (18 #f)
                             (-1 -2)
                             (else #\U000C6623))
                           (if #\쫟 #f #f))
                       (integer->char (if #\U000DB9BD #\U000BD4A9 #t)))
                      (#f #t)
                      (#f #f)
                      (#\貉 #\힙)
                      (else #f))
                    -5)
                   (#f
                    (if (cond
                          (#\U000174B6 (zero? #t))
                          ((abs 2) #\U000D50DB)
                          ((cond (0 -4) (else 4)) (if #f #f #f))
                          (#t (integer? #t))
                          (else
                           (cond
                             (#f #f)
                             (#f #\U000E7B95)
                             (#f #f)
                             (#f #t)
                             (#f #t)
                             (#t 8)
                             (18 #f)
                             (#t #\注)
                             (else #\U000B978D))))
                        #f
                        #t))
                   ((abs (if (if #t #\檤 -2) #f #t)) #t)
                   (#f #t)
                   ((add1 #\넨) #f)
                   (else -2))
                 #\薨)
                (4 #\ᰬ)
                (#t 1)
                (#t #f)
                (#f #\ഛ)
                (#f #t)
                (#\ᨒ
                 (-
                  (cond
                    ((cond
                       (#f (char->integer #t))
                       (#t (integer->char 1))
                       (#f #t)
                       (#\U000C828A (- #t))
                       ((cond
                          (#\U000D782C #f)
                          (3 #t)
                          (#t -3)
                          (#t #t)
                          (#\¨ 8)
                          (16 #f)
                          (else #t))
                        #\솳)
                       ((cond
                          (#t #f)
                          (3 0)
                          (#f #\𨛂)
                          (#f #f)
                          (#f #\놅)
                          (2 #\U0009F98D)
                          (#\ꅉ #\U0004DB0E)
                          (else #f))
                        (if 1 #\U000FE2AA -4))
                       (#f (cond (#\U0001E560 -4) (#t #t) (else #\U000B09EE)))
                       (else #f))
                     (cond ((if #\ꄣ #f #t) -2) (else #\U00034EE8)))
                    (-6 #\䔎)
                    (#t (cond ((- -4) #\컯) (else -16)))
                    (#f (sub1 (char->integer #\Ⴁ)))
                    ((zero? (if #t #\릊 #f)) (if #f #t (if #f #\꧴ #f)))
                    (else (if #\U00042A7E -16 1)))))
                (-1 #\U000ECE07)
                (#\uE42E #\U000ADA62)
                (#\ࡏ -4)
                (#f -1)
                (#f 6)
                (#\𓋈 #\ꯇ)
                (3 2)
                (#\𝜢 #f)
                (else #\笍)))
             (else (let ((b2 #f)) 1)))
           #\࠴
           (cond
             ((boolean? #f) (let ((e0 #f)) #f))
             ((cond
                (#\uABAB (cond ((cond (else #t)) (integer? #\U00077168)) (else #t)))
                ((integer?
                  (cond
                    (#t (if #\U00041515 -5 #f))
                    (#f #t)
                    (#\䙠 (integer->char #\u0A5F))
                    (#\蕲 0)
                    ((cond
                       (1 -5)
                       (#\荿 1)
                       (#t #f)
                       (#f #t)
                       (#\ể #t)
                       (#f #\䓒)
                       (1 4)
                       (else #\U000946B2))
                     #f)
                    (#f
                     (cond
                       (-6 #\ᑭ)
                       (#t #t)
                       (#f #\둩)
                       (#\U000B6776 -3)
                       (#\焗 12)
                       (#t -1)
                       (#f #\窥)
                       (#f #\ᴥ)
                       (else -4)))
                    (#\U000AB8CF #\㊩)
                    (else (integer? #\鉺))))
                 -2)
                (-1 (if #t 513 (cond (else #t))))
                (-2 (if #f #f #\U000F82C2))
                (#t -4)
                ((cond
                   ((if #t (cond (-3 #f) (#f #\U000684EB) (else #f)) #f)
                    (if (cond
                          (#\U0002E9AF #\凥)
                          (-4 2)
                          (#\U0004FBE7 #t)
                          (0 -1)
                          (#f #f)
                          (3 #t)
                          (-1 #t)
                          (#t -3)
                          (#f 2)
                          (#t -8)
                          (#t #\uEB47)
                          (-1 #f)
                          (#f #\U000CDA43)
                          (-1 #t)
                          (#t #f)
                          (#f #t)
                          (else #\楕))
                        4
                        #t))
                   (else (if #t #\U000D1B06 #f)))
                 -3)
                (else #\U000AABFC))
              #f)
             (-1
              (cond
                (#f #\U000FE425)
                (#\U0010F59F #f)
                (#\桁 #\掐)
                (#\瑙 #t)
                (#t #t)
                (else #f)))
             (else (integer->char 4))))
       #t)
      (#t #f)
      ((zero? (if (cond (else 2)) (add1 #f) (char->integer #t)))
       (abs
        (cond
          (5 (if #f #\饢 -1))
          ((if #f #f 1) (if #f #t #\𝓬))
          ((let ((i1 3)) #\U001085CC) (if #t #\U000C834E #t))
          (else #f))))
      (#f
       (cond
         (#t
          (cond
            (#t (zero? -17))
            (#t #f)
            (-5 5)
            (#f (let ((n0 #\U0008AD75)) #t))
            ((let ((o0 2)) 4) #t)
            (0 #f)
            (#f (char? 4))
            ((boolean? 2) #\↭)
            (else (cond (else #f)))))
         ((cond
            (#f #f)
            (6
             (cond
               (#t #f)
               (4 -4)
               (#f #\넞)
               (#f #t)
               ((char->integer
                 (cond
                   (#f #t)
                   ((cond (else (cond (#t #f) (#t #f) (else #f)))) -1)
                   (#\U00041E4C #f)
                   (else (zero? -3))))
                -2)
               (#f 4)
               ((abs 1) #t)
               (-3 -1)
               (else #\U000E30E4)))
            (else (char->integer #f)))
          #\U001073CE)
         (else (if #t #f #\ꨗ))))
      (#t #f)
      (0 #t)
      ((if #t
           (cond
             ((if #t #f 20) (if (if #\踟 3 #t) (char->integer #t) #\뇱))
             (else (if #\褒 2 1)))
           #t)
       (char->integer (if (if 5 #t -2) (integer->char #\𦭟) (let ((e2 #\膊)) 1))))
      (else (integer? #f)))
    #\U000432C3
    #t
    (cond
      (#t (integer? (zero? #t)))
      ((boolean? (let ((b1 (add1 2))) 4)) #t)
      (-1 (integer->char #\U0004EC7E))
      ((if (cond ((if 0 #f #f) #t) (else #\U000802D8))
           (zero? (cond (else #\봠)))
           #f)
       #\U000CC83D)
      (#f #\U00109326)
      (#f #t)
      (-2 #f)
      ((char->integer #\U00042470)
       (let ((l0
              (if (cond
                    (0
                     (cond
                       (-5 3)
                       (-1 #t)
                       ((if #t
                            1
                            (cond (#f #t) (#t #t) (4 #\䌈) (else #\U000C2939)))
                        (sub1 #\U0010278C))
                       (#f #f)
                       (#t #f)
                       ((if (if 3 -1 #f) (if 3 #f #f) #f)
                        (cond
                          ((if #f #f #t)
                           (cond (#f #\U0003681C) (#\U000B539C #t) (else -2)))
                          (#\ꏕ (if -16 #t 3))
                          (#t #\螤)
                          (else #\늖)))
                       (#\U0009D227 1)
                       ((cond
                          ((cond (#t -17) (-21 #f) (else #t)) #\U000DB203)
                          (#\墜 #t)
                          ((boolean? #\U000D52FD)
                           (cond
                             (#f #\U0007B2C5)
                             (#t #f)
                             (4 #\U000A3531)
                             (#t #t)
                             (else #t)))
                          (#t (char->integer #\U000CB9DD))
                          ((if #t #f 1) 2)
                          ((integer? #f) #\߬)
                          (-2 #f)
                          (16 1)
                          ((sub1 #f)
                           (cond
                             (#f #\懗)
                             (#f #\U000C8A1E)
                             (#\贜 #\𪦵)
                             (#\닣 #\U000591D7)
                             (2 #f)
                             (#\U000B81BC #t)
                             (#t -4)
                             (else #\ߨ)))
                          ((if #f #t #\U00068872) (if #t #\嚚 #t))
                          ((cond (else #\U0004ABA8)) #t)
                          (#t #\U000371EE)
                          ((integer->char #t)
                           (cond
                             (#f #f)
                             (-1 #\U000C3068)
                             (#f #t)
                             (#f #f)
                             (#f #f)
                             (#\U000C340C #\٠)
                             (#\U000DCCE8 #f)
                             (else #f)))
                          ((cond (3 5) (1 #\U0006129C) (#t #f) (else 1))
                           (integer->char -4))
                          (3 #\鸽)
                          (#\U00059120 (cond (#t 1) (-7 #f) (else -3)))
                          (#\U000A8151 (cond (#f #t) (else #t)))
                          (#f
                           (cond
                             (#\킷 #f)
                             (#f -10)
                             (-3 #t)
                             (#\犍 1)
                             (#t #\U000BB0CA)
                             (#t #\U000920BA)
                             (#f #\ㅱ)
                             (#t 3)
                             (#f #f)
                             (else 5)))
                          (#t #f)
                          (else #t))
                        #t)
                       (#f (cond (else #t)))
                       (else
                        (char->integer
                         (cond
                           (#\タ #\U000CBA9F)
                           (#\햎 -2)
                           (#\𧀓 #t)
                           (#t 17)
                           (#f #f)
                           (else #\U0007600F))))))
                    ((if (cond
                           (#t 3)
                           ((boolean? #f) (boolean? #t))
                           ((cond
                              (2 #t)
                              (#f #f)
                              (#f #t)
                              (#f #\U000901B6)
                              (7 #\쭭)
                              (#f #t)
                              (#f #t)
                              (#f #t)
                              (#t #\䍩)
                              (#t #f)
                              (-1 1)
                              (2 #t)
                              (-5 #\㓱)
                              (#f #t)
                              (#\묚 #f)
                              (#f 2)
                              (#f 1)
                              (#\轓 -2)
                              (#\U000874BB #f)
                              (#\U000D79BB #f)
                              (#t #f)
                              (#\U0008DD90 -1)
                              (else #t))
                            (cond (#f #f) (#\U000BBF48 #\u089D) (else -6)))
                           ((zero? 1) (integer? #f))
                           (0 #f)
                           ((integer->char #\応) #\沑)
                           ((cond
                              (#\砑 #f)
                              (#\𫞖 #t)
                              (#\⫪ #t)
                              (#f #\獤)
                              (#t #\緓)
                              (#t #t)
                              (#t -1)
                              (#t #\U000BAE9C)
                              (else #t))
                            (cond (#f #\䏭) (else #f)))
                           (#t (integer->char #\U000D94C2))
                           (#\U000437BE #f)
                           (#f (- #\U000FF237))
                           (4 (integer->char #t))
                           (#f (if #t #t #t))
                           (#t (if #t #f -3))
                           ((if -16 #t -7)
                            (cond
                              (0 4)
                              (#\U000DAC82 #f)
                              (#t 1)
                              (2 -1)
                              (#\U000DA4D0 #t)
                              (-5 4)
                              (else #\U000421D7)))
                           (#t (if #t #f #\뗉))
                           (else #f))
                         (if #f
                             (cond (#t #f) (#f -2) (#t -2) (#t #\U000E1FCD) (else 3))
                             #t)
                         #\U000D3055)
                     #\U0004E58E)
                    ((if (if #f #f #t) -5 3)
                     (char? (cond (#t -2) (else (if #f -2 #t)))))
                    (#t
                     (cond
                       (#t 2)
                       (-3 17)
                       (#f #t)
                       (-1 -2)
                       ((integer? #t) -2)
                       (else (add1 #t))))
                    ((char?
                      (cond
                        ((cond
                           (2 #\U000C043C)
                           (#t #f)
                           (#\뾆 -2)
                           (2 4)
                           (#t -4)
                           (#t #f)
                           (4 8)
                           (else #f))
                         4)
                        (#f (if #f #t #\U00019910))
                        (0 (cond (#f 2) (#t #t) (#f #f) (else #t)))
                        (else (zero? #t))))
                     #t)
                    (-1
                     (cond
                       ((if #t #\𧱟 (abs #\U0005534E)) #\U0001FAED)
                       ((integer?
                         (cond
                           (2 #\횳)
                           (#\尺 #t)
                           (#f #\U000C5C3C)
                           (#t #f)
                           (#f #f)
                           (#f #f)
                           (#\낭 #t)
                           (-1 #t)
                           (-2 #t)
                           (#\U00071CB2 #\U00095A0A)
                           (4 #f)
                           (else #t)))
                        (add1 #f))
                       ((cond
                          ((if #f #\U00019549 -8) (- #\ꐸ))
                          (#f (if 3 #f #t))
                          (else (char->integer #t)))
                        (if (cond
                              (#f #t)
                              (#\U00075FFA #t)
                              (4 #f)
                              (#t #t)
                              (#t -2)
                              (#t 2)
                              (#\뱘 #\U00056CEA)
                              (#t #f)
                              (#t #\鹰)
                              (#t #\솀)
                              (#f #\U0005F0EA)
                              (else #t))
                            #t
                            (cond (#f #t) (#f #f) (else #t))))
                       ((if #t #f #\U000C4832) #t)
                       (-2
                        (if (cond (-3 4) (#t #t) (else #t))
                            (cond (#f -2) (#t 18) (else #\됾))
                            (if -1 1 -2)))
                       ((cond
                          (1 #f)
                          ((if #t 3 #\U000E7876) (if #t #\U0004E2F4 #\U000B2F25))
                          (#t (if #t #\𫟑 #t))
                          (#\𪞏 (cond (#f #\𢡶) (else 0)))
                          (else #t))
                        (integer->char #t))
                       ((abs #\嫪) #\U000159B0)
                       (#f #t)
                       (#f (if (if #t #f #\厩) #t 1))
                       (else 3)))
                    (#\U0008E7B4 #t)
                    (else 4))
                  (let ((j2 #f)) #\칳)
                  #t)))
         (let ((n1 #\괍)) #f)))
      (#t #t)
      (else (cond (3 #\U000383A0) (else #f))))
    #\U00039B56
    #t
    (add1 #\U00033516)
    -3
    (let ((l2
           (let ((b2
                  (cond
                    (#f
                     (cond
                       (#\U000C8ABC 3)
                       (#f #t)
                       (#\푏 #f)
                       (#t #\U000B6671)
                       (#t (if #t #t #t))
                       (2 #\U00059072)
                       (#t (cond ((if #t #t -2) #\ꊗ) (else -3)))
                       (else (integer->char #t))))
                    (else
                     (cond
                       (#\u0A64 #\U00056490)
                       (#\U0010FF0A #t)
                       (#\U00100B43 #\泜)
                       (else #\U00012AA4))))))
             (abs (char? #t)))))
      (cond (l2 l2) (else #f)))
    (let ((n0 #t)) (integer->char (char? (char->integer -1))))
    (if #f (char->integer 4) (abs #f))
    #f
    (let ((c1 (cond (#t 1) (else #t))))
      (cond
        ((let ((b0 (let ((y0 3)) #\U0005AE8E))) (let ((d1 c1)) #\딸)) c1)
        (#f (if -1 #f #\U0006288B))
        (c1 #t)
        (#\U0008EE46 (let ((j1 #f)) (if #f 9 #f)))
        (#\失 c1)
        (#\ꙷ #t)
        ((let ((d0 (- #f))) (if #\麃 #\驑 #\U000D6495))
         (let ((d2 -3)) (cond (else #f))))
        ((let ((v1 (integer? c1))) (let ((z0 16)) c1)) (cond (else #t)))
        (#f #t)
        (else #\U00106A90)))
    -2
    4
    (let ((t0
           (integer->char
            (if (cond
                  ((boolean? #t) (cond (#t #\U00100FA9) (else #t)))
                  ((sub1 #t) #t)
                  ((zero? #\硘) #f)
                  ((- 2) (if #\루 #t #\澈))
                  (#\뀄 -7)
                  (#\U00106FA3 (boolean? #\U00035043))
                  (#t #\U000FCC67)
                  (#\U000BCA32 (cond (#\輺 #f) (#\U000FC9EA #t) (else #t)))
                  (else (if #\U0008E7EC #\恼 #f)))
                (if -1 (if #f -1 -1) -1)
                0))))
      (cond (else -2)))
    (let ((b1 #\u0FE2)) (integer->char b1))
    (boolean? #t)
    #f
    (char->integer #t)
    (let ((l1 #t))
      (cond
        (#t -7)
        ((cond
           (#t #f)
           ((let ((o1 3)) #t) 2)
           (#f (char->integer #f))
           (else (let ((c1 l1)) -3)))
         (let ((q0 (if #f #f #t))) q0))
        (#t
         (cond
           ((sub1 l1) (cond (else 2)))
           (else (cond (-11 #f) (#\舟 #t) (#f #f) (#f l1) (-16 l1) (else -2)))))
        (else
         (let ((n0 (let ((q2 #f)) l1)))
           (cond (-4 #f) (#f #t) (#t 16) (#t #f) (#\㗕 #f) (else #f))))))
    (sub1
     (cond
       (else
        (char?
         (if (cond ((add1 (zero? -1)) (sub1 -3)) (else #t))
             (if -4 (boolean? #\U000A848B) -2)
             #t)))))
    #f
    (let ((s0 2)) #t)
    -3
    (let ((w1 #\嵱)) -3)
    -3
    (if (abs #f)
        1
        (if (cond (else #t)) 1 (if -5 (if 1 (if #t 10 2) -4) (abs 0))))
    (let ((h2 #\湢)) (let ((h0 #t)) #f))
    #\ꓰ
    #t
    (if #\U000D7E04 (integer? -1) 2)
    (sub1 (char->integer (if (abs #f) #f -5)))
    (cond (#f 0) (else 0))
    (if (cond
          (#f #t)
          ((cond
             ((cond
                (#f 1)
                ((cond
                   ((char->integer #\U000FBAD6) -5)
                   ((if (cond
                          ((if #t #f #t) (add1 #f))
                          (#f (cond (-1 4) (#f #\ᆎ) (#\藯 #t) (#t #t) (else #t)))
                          (8 (sub1 #\U000E3633))
                          (-4 #\U00039802)
                          ((if #f -4 #f) (if -4 #\燩 #t))
                          (#\笋 #f)
                          (#\U0008B811 #\U00050FD1)
                          ((integer->char #t) (integer? #\㢔))
                          ((if #\ꡪ #\𪎠 #t) #f)
                          (#f
                           (cond
                             (#t #\U000ADC41)
                             (#t #t)
                             (#\⤀ #f)
                             (#\㈃ #f)
                             (#f #t)
                             (#\㾪 #\U000B930B)
                             (0 #t)
                             (-7 #t)
                             (else #f)))
                          ((cond (else 2)) (boolean? #f))
                          (else #t))
                        3
                        (if (sub1 #t) #t (abs #t)))
                    #f)
                   ((if (cond
                          (-2 -1)
                          ((cond (#f -1) (-2 #\U000E89B3) (else #t)) #f)
                          ((cond (#f #f) (else #\쒗)) (abs #t))
                          ((zero? #t) (if #\㊙ 3 #\썎))
                          (else (sub1 #\陴)))
                        #t
                        (if (if 3 -2 3) #f (if #t #t #\U000B26A3)))
                    (if (if (cond (5 2) (#\堣 #\㒖) (#\U0004603C #t) (else -3))
                            #t
                            (add1 #f))
                        #f
                        #t))
                   (6 #\U000466BF)
                   (else
                    (cond
                      ((cond (else (if #f -2 #\U000B43C3)))
                       (cond
                         ((cond (#f #t) (else -8)) -1)
                         (#t #f)
                         (else #\U0003FAE3)))
                      (else (add1 8)))))
                 (integer->char
                  (char->integer
                   (cond
                     ((if #f #t 4) #f)
                     ((if #t #\U00061460 #f) (add1 1))
                     ((integer->char -2) #\𢔤)
                     ((cond (-1 #\阜) (#f #t) (else #t)) 4)
                     ((cond (#f -64) (#t #f) (else 8)) (- -2))
                     (else #f)))))
                (else #\彏))
              -8)
             (else #\U00063D41))
           (- (let ((i1 #\ꪳ)) 3)))
          (2 (zero? #t))
          (#f #\U00078AA0)
          ((let ((e0 0)) #\U000E094D) #f)
          ((if #f
               (char->integer 4)
               (char?
                (if #f
                    (cond
                      ((integer->char (cond (else #f))) 1)
                      (3
                       (if (cond
                             (#t #t)
                             (-1 #\뵉)
                             (#f 9)
                             (#\U00086218 #f)
                             (#\䉘 #t)
                             (#t #t)
                             (-16 #t)
                             (#t 6)
                             (#\U0001EBB2 #\𢊊)
                             (else #\覢))
                           #\핆
                           #t))
                      (#t (abs (if #t 3 #\ⱨ)))
                      (#\U0003490D
                       (if (cond (#\纞 -9) (#f #\U0007ABEC) (#t #\Ȣ) (else #f))
                           (add1 #f)
                           #f))
                      (#\៌
                       (if (boolean? #t)
                           (char->integer 2)
                           (cond (5 #\逼) (#f #t) (else #f))))
                      ((cond (else (if #t #t -3))) -2)
                      (#f -1)
                      (else (boolean? #f)))
                    #f)))
           #t)
          ((if #f #t (char->integer #f)) (if (char? -32) (let ((f0 -3)) #f) 2))
          (else
           (cond
             (#t #\U000E40CC)
             ((let ((h0 #f)) #f) (let ((a0 #f)) 1))
             (else
              (cond
                (2 (integer->char #f))
                ((add1 #\U000FA00E) (add1 #f))
                (else -1))))))
        #\U000E83AD
        (cond
          ((boolean? #\╣)
           (if (char? 5)
               (cond
                 (#\艴 #t)
                 (#t (if #\U0008080B #t #t))
                 ((cond (#\U0001A10E 1) (#f -1) (16 #t) (#\対 -4) (else #\⥯)) #t)
                 ((zero? #t)
                  (cond (-1 #\U000A7AD0) (#f #\U0003C146) (#t #\돎) (else #t)))
                 (#t #\U000EE4BE)
                 (-5
                  (cond
                    (#f #t)
                    (#\u0604 #f)
                    (#\䵛 #f)
                    (#f #f)
                    (#f #\ꚗ)
                    (#\츳 #t)
                    (#t #\U000618E7)
                    (#f #\U000FCAD1)
                    (#\穟 #\U000CDFD0)
                    (#t #\蝗)
                    (#\U0007E0D7 3)
                    (#\U00107A41 #t)
                    (11 -3)
                    (1 #\U000CEF0B)
                    (#f #f)
                    (else #f)))
                 (else -1))
               (char? 2)))
          ((cond
             ((zero? #\㻯)
              (if #f
                  (cond
                    (#t 2)
                    (#f #t)
                    (#\U00014582 #\U0003E038)
                    (4 #t)
                    (-2 #t)
                    (2 #f)
                    (else #\◮))
                  (zero? #f)))
             (#f #t)
             (#t 1)
             ((- (if 1 0 -3)) (if #\U000F2D99 #t (boolean? #f)))
             ((if (cond (#t #f) (-1 32) (else #\U000CAD18))
                  (if #f #\U0004AFFE #\U00018F6A)
                  #\腼)
              #f)
             ((cond
                (#f (- #t))
                ((if #f #f -4) -2)
                (#t 1)
                (#t -3)
                ((cond (else -1)) #t)
                ((- #f) (cond (else 2)))
                (#\噮
                 (cond (#t #\U000372E2) (0 -4) (#t #f) (#t -10) (else #\U000DA176)))
                ((char->integer 7) #f)
                ((char? -1) (if #f #t #t))
                (else #\賾))
              (if #\U00045DB8
                  (if #\U0003B131 -12 #t)
                  (cond (3 #\U000E4D11) (#t #t) (#\U0008113A #f) (else 2))))
             (#t 4)
             (else #\Թ))
           #t)
          ((if #t #t (if #\쉜 #f (if #\풎 #\U000C07EA #t)))
           (if (cond (#t (cond (else #t))) (else #f)) #f #f))
          (1 #t)
          ((boolean? #t) (boolean? 0))
          (2 #f)
          (#f (cond (#\U0009708E -6) (else -2)))
          (#\U000A26CB #\U000411CC)
          (#f #t)
          (-3 1)
          ((if (if #t #\U0001EDF3 #f) (integer->char #t) #t)
           (cond
             (#\ྖ #\U000DB9A7)
             (#f
              (cond
                (-1 (boolean? #f))
                (#t (cond (#t #\舫) (-4 1) (-4 -3) (else #f)))
                ((if #\騝 #\U000645F9 #f) #f)
                (else #\䩵)))
             ((char? (- #f)) (cond (else #f)))
             (#t -2)
             (#f #f)
             (#f #f)
             (#\𥂸 (if #f (integer? 2) (if 2 3 19)))
             ((cond (else (if #\U0008D8F8 #f -1))) (cond (#f #f) (else #f)))
             ((sub1 #\ⱹ)
              (boolean?
               (cond
                 (-3 -4)
                 (#t -1)
                 (2 #\U0008743B)
                 (#\검 #\େ)
                 (else #\U0003237E))))
             (0 #f)
             (else
              (if #\u2D2C
                  (cond
                    (#t #t)
                    (#f #f)
                    (#f -8)
                    (#t #\U0010A447)
                    (#\U000E05C3 #f)
                    (#\㽡 #\u0EE6)
                    (#\ᖘ #\𧙗)
                    (#t #f)
                    (else -3))
                  (if #\皤 #t #f)))))
          (#f #f)
          (else #f)))
    #f
    (cond
      ((if #f
           (if (sub1 -12)
               -2
               (cond
                 (#f #f)
                 (#\𡃚 #\힙)
                 (#t #f)
                 (-1 #t)
                 (#\똟 #t)
                 (#\u08E2 -2)
                 (-1 (abs #f))
                 (#f #f)
                 (else #\淼)))
           #t)
       (char->integer #t))
      (#t (abs #f))
      (#t
       (sub1
        (cond
          (33 #\U0010398B)
          (#\㪮
           (cond
             (#f #\U000FB8E4)
             (#f #\U000E7878)
             (#f #\U000AC86E)
             (#t
              (cond
                (-1
                 (if (if (cond (else #t)) #\畸 (char->integer #t))
                     #f
                     (cond
                       (-4 #\U0008CCC5)
                       (#t #f)
                       ((integer? #f)
                        (cond (#f #\U000A59A9) (-2 #t) (#\띂 #t) (else #t)))
                       (#\U0010B8B2 (cond (else -3)))
                       ((sub1 #t) #f)
                       ((cond (#\架 #\ꛉ) (else 2)) #t)
                       ((char->integer #\U000F55BA)
                        (cond (#\鐫 #t) (#t #t) (#t 2) (else #t)))
                       (-17 7)
                       (#\茊 #\ז)
                       (#\U0008D8B7 (if #t #f #t))
                       (-2 #f)
                       ((sub1 #f) (sub1 #\ꎖ))
                       ((if #t -4 #f) (cond (#\U000E4C13 #f) (else #t)))
                       (#f
                        (cond
                          (#t -4)
                          (#t #t)
                          (#\U000D1B9E #\U000669DB)
                          (#f -7)
                          (else #\U0007731E)))
                       ((if 2 #f #\U00034DFA) #t)
                       ((cond (else -21)) #\⩍)
                       ((boolean? 3) (cond (else #t)))
                       (#t (if #f #f 34))
                       (#t -2)
                       (-1 -3)
                       ((- #\U0007E85C) #t)
                       ((cond (#f #\U000B3562) (0 4) (else 3)) #t)
                       (else #\U000B66A5))))
                ((if (zero? #f) (if #\睱 #\謴 (if #\U000EDC9F #\廜 #t)) #\U00066146)
                 (cond
                   (#\U00094687 4)
                   ((char? -1) #\ᇥ)
                   ((if #t #t (char->integer #f)) -2)
                   ((if (cond (#\藄 8) (else #t)) #f -4) -1)
                   (#f #\U000197E5)
                   (4 #\U000EDA92)
                   (4
                    (sub1
                     (cond
                       (#f #\U000A3F7B)
                       (#\U000CC6B4 #\U00097DE3)
                       (#f #\௸)
                       (-2 #f)
                       (-1 #\❥)
                       (#t #f)
                       (else #t))))
                   ((char->integer (zero? 3)) 2)
                   ((if #\U000DC397 (sub1 #t) #f)
                    (if (if #t -1 2) (if #f #f #t) #f))
                   (else #f)))
                (#\U00013EF3 -1)
                ((cond
                   (32 #\줈)
                   (#f #f)
                   (#f (if #\쩁 2 #\룁))
                   ((if (cond (#f #\⟗) (else #t)) #\ᬣ 4) 3)
                   ((cond (#f #f) ((if #f #t -2) #t) (else #\쾟))
                    (cond (5 (if #\얛 #\ޟ -2)) (2 #f) (else #\ꬤ)))
                   (#f #\㕇)
                   ((integer->char -1)
                    (cond
                      ((cond (#\镎 #f) (#t -134) (else #\ᘁ)) (if #\毊 #t #\虷))
                      (3 #\렾)
                      ((if #\U0005176C 1 -3) #t)
                      (8 -2)
                      (else (integer? #t))))
                   (#t (if #\ⵣ (cond (#f -1) (-1 #t) (else #f)) (if 0 #f #f)))
                   (#\瀌 #\U000D48BE)
                   (else (if #\uFFFA (if #\魐 #t 1) 1)))
                 #t)
                ((zero? #f) (sub1 (if (cond (else #\U000B2133)) (if #t #f #t) -6)))
                (#f #t)
                (#\U00058476 (boolean? (cond (else #t))))
                (else -4)))
             (#\U000C550B #t)
             (#\趫 0)
             (else #\U000DE5DA)))
          (#f
           (cond
             (#t #t)
             (#\U0002BE47 #\U000E7994)
             (#t #f)
             (6 (if #\U0008C568 4 #t))
             (#f
              (cond
                (#\陙
                 (if 9
                     (abs #f)
                     (cond
                       (#t
                        (cond
                          (#f #f)
                          (#t #t)
                          (#\ᔟ -2)
                          (-8 4)
                          (-2 #f)
                          (#\u1717 #\傼)
                          (#t #t)
                          (else -1)))
                       (#t -1)
                       ((cond
                          (#t #f)
                          (#t 2)
                          (#\玜 #\U0010D0B7)
                          (-1 #f)
                          (#\渍 #\U000D3D76)
                          (#t #f)
                          (#t #\U0001E344)
                          (#t #f)
                          (#t #t)
                          (#t #f)
                          (else #f))
                        (if #f #\駻 #t))
                       ((cond (#t #f) (#f #\U00068734) (#t 2) (else #\欯))
                        (cond (else #f)))
                       (4 #t)
                       (#f (cond (0 2) (1 #t) (else -5)))
                       ((cond (1 #t) (#f #t) (else #\蓘)) #t)
                       (1 (zero? 0))
                       ((cond
                          (-6 #f)
                          (#\㣰 #\俻)
                          (4 #\ꗩ)
                          (#\ᢵ #t)
                          (#\U00068626 #t)
                          (else #\先))
                        (cond (#\䇖 #t) (#\匌 #\U00016626) (else #f)))
                       ((if 2 #t #t) (cond (else #t)))
                       (-2 -1)
                       ((if #\U000DAD4B -3 #t) (abs -6))
                       (#t #t)
                       ((cond (else #f)) (char? 1))
                       (#\U00056349 (sub1 -1))
                       (else (if #f #\U000A908C 1)))))
                (#f -11)
                (#\ꏥ (- #\轔))
                (#\U00098745 129)
                (#\U0002D92F 1)
                ((if #f #t #t)
                 (cond
                   (4
                    (cond
                      ((boolean? #t) (cond (#\U000FCF83 #f) (else #\U000AEEA1)))
                      (#t (cond (else #\ꁙ)))
                      (#f #f)
                      (#t (cond (#t #t) (5 #t) (else #\㉘)))
                      (else (cond (else #t)))))
                   ((boolean? #t) #t)
                   (else
                    (if (char->integer -2)
                        (cond (-3 #t) (0 #t) (#f #\U000E125E) (else #f))
                        (if #t -1 #t)))))
                ((zero? #\엷)
                 (cond
                   (#f (abs #\䠍))
                   (#f (char? -1))
                   (#\Ф
                    (if #f
                        #f
                        (cond
                          (#t #t)
                          (#t #f)
                          (0 #\ꏄ)
                          (#t #t)
                          (#\̿ #\租)
                          (#\U00057398 #\ዝ)
                          (#\땨 -1)
                          (#\Ḙ #\ྒ)
                          (else #f))))
                   ((char->integer #\മ) (cond ((zero? #t) #t) (else #t)))
                   (#f
                    (cond
                      ((char->integer #t) #f)
                      ((cond
                         (-4 #\U0010C658)
                         (0 #t)
                         (#t #t)
                         (#f #f)
                         (#\U0005033E #\U000AFF73)
                         (else #t))
                       #\u9FE0)
                      (else #f)))
                   ((cond (else #\U000A8636)) #f)
                   (8 #f)
                   (#\뽉 5)
                   (else 1)))
                (#t 2)
                (#\U0003C723 (cond (#\𨆗 #\▣) (else #f)))
                (#t -128)
                (-5 (boolean? (boolean? (if -2 #t #\U0010FBB7))))
                ((if (- #t) -3 (integer->char (if #t #\ᶞ #t))) -4)
                (-2 -1)
                (-3 #f)
                ((cond
                   (#f (boolean? (- #f)))
                   ((zero? #\剟) #t)
                   ((if -1 (if #f #\U000DE069 #\U000E8ED6) #\衺)
                    (if (char? #\猀)
                        (cond
                          (#t #f)
                          (#t -1)
                          (#\ু 4)
                          (#f -4)
                          (#\𑁄 -9)
                          (5 #t)
                          (-19 #f)
                          (#t #f)
                          (else #f))
                        (if #t #\U000B03B2 #t)))
                   (#\U0004D05D -3)
                   (5 #f)
                   (#t (zero? #t))
                   (#\熨 #f)
                   (#\U00041DEF #t)
                   (9 #t)
                   (#t #f)
                   (-1
                    (if #\U000C9CC0
                        (cond
                          (#f #f)
                          (#\U000E1DC6 #t)
                          (#t #t)
                          (#t #f)
                          (#f -3)
                          (8 #t)
                          (else #t))
                        4))
                   (#t (boolean? #f))
                   (-3 -2)
                   (#\㮐 #f)
                   (else #f))
                 #\U0003FD2D)
                (0
                 (cond
                   (-2
                    (if (cond
                          (#t 4)
                          (#f #\U0002E534)
                          (#t #\U000BA848)
                          (#\U000DFC12 #\咄)
                          (else 5))
                        (cond (#\흧 #\U0005B898) (#f #f) (5 #f) (else #t))
                        (integer->char #f)))
                   (#f
                    (cond
                      (#\扥 (if #f #t #\U000E3016))
                      (2 #\U000CC66F)
                      ((integer->char #t) (if -2 #\劈 #f))
                      (-4 1)
                      ((if #f 3 #\䂼) (- #\㴝))
                      ((if #t #\䃣 #f) #\U000D3E30)
                      (8 #t)
                      (#t (if 3 #\욛 #f))
                      (#f (- #f))
                      (else (cond (else #t)))))
                   ((- (if #\큌 #t 4)) #t)
                   (-1 #\徛)
                   (4 (if -2 (cond (#f #f) (else #\U00069D02)) #f))
                   (#\翜 0)
                   (else -2)))
                (#f #t)
                ((if -1 #\摉 #t) #\祊)
                ((char->integer (- #f)) #\U0001F91C)
                (else #\U00042F25)))
             (else #\ⱡ)))
          (#\㓴 (let ((g0 #f)) #t))
          (#t -1)
          (else (zero? #\U0004EE28)))))
      (#t (if 3 (if (char? -1) (add1 8) #t) #f))
      (#\瓄 #\ɣ)
      (#\㽡 (char? (let ((e1 -1)) (if -4 #t #\큯))))
      ((let ((b0
              (cond
                ((let ((g0 1)) g0) (if (abs #\迍) #\琐 #\u2DA7))
                (else (let ((p1 #f)) #t)))))
         -6)
       (if (if #f
               (if (if (integer->char -1) #t #f)
                   (cond (else #f))
                   (zero? (integer? #t)))
               (if #f 3 (integer? #t)))
           (sub1 (if -34 #t #t))
           #t))
      (else
       (cond
         (#t (zero? #f))
         (#f #\䠔)
         (#f (let ((v0 (abs #t))) #t))
         ((let ((z0 (integer->char #f))) 3) (zero? (let ((k1 #t)) -3)))
         ((integer? (cond (else -4))) #t)
         ((zero? 3) #f)
         ((if #f #f (abs #t)) (let ((o0 #\U000ABF19)) #f))
         (#\अ
          (let ((j0
                 (if 1
                     #\ᴨ
                     (cond
                       (#f 2)
                       (2 #\U00049A5A)
                       ((if 2
                            (if (integer->char #t) (if -32 #t #t) #\U0009C37C)
                            (cond
                              (#f (cond (else #\U00066014)))
                              (#t #t)
                              (#f (cond (4 #f) (else #\杽)))
                              (-13 #\砅)
                              (#f 4)
                              ((add1 -2)
                               (cond
                                 (#f #t)
                                 (#f #\拤)
                                 (#t #t)
                                 (#t #f)
                                 (-1 #t)
                                 (#\払 #t)
                                 (else #t)))
                              ((cond
                                 (#t -3)
                                 (#t #f)
                                 (#\U000F04C6 -1)
                                 (#f #t)
                                 (#t -18)
                                 (#f #f)
                                 (#t #\U000B36CB)
                                 (#t #t)
                                 (-2 1)
                                 (else #\ꇮ))
                               2)
                              ((cond
                                 (#f -2)
                                 (#t 2)
                                 (1 #f)
                                 (#f #\U000FC95C)
                                 (-1 #t)
                                 (#\谚 #\돦)
                                 (else 1))
                               #f)
                              (else (if #f #f 5))))
                        (cond
                          ((- #t)
                           (cond
                             (0
                              (cond
                                (#\艣 #t)
                                (#t #t)
                                (-3 16)
                                (#\ꗟ #t)
                                (#f -2)
                                (#t 5)
                                (#f #\犞)
                                (#t -17)
                                (else 4)))
                             (#t -2)
                             (#t #\U000CE2DF)
                             ((if #f #f -1) #\⇜)
                             (4 #\활)
                             (4 -3)
                             (else #t)))
                          (-4 #f)
                          ((abs (if #f #t #\ő)) #t)
                          ((abs (char->integer #f))
                           (if #\U00032EB7
                               (char? #f)
                               (cond (-2 #\쩵) (#t #t) (else 16))))
                          ((cond
                             (#f #t)
                             (#t -2)
                             (6 #f)
                             ((if 6 #\U000D8B79 #f) -6)
                             (#t (integer->char #t))
                             ((- #t) (sub1 #\ᣖ))
                             (else (char->integer #f)))
                           #\U00055E93)
                          ((cond
                             ((if #t #\U000985C8 #t) (cond (#t #f) (else -2)))
                             ((integer->char #\Ӆ) #f)
                             ((char? #\U000C45CD)
                              (cond
                                (#f #\㱰)
                                (#\U00073FE8 #\U000B2D5E)
                                (else #\U000868C0)))
                             (#t #f)
                             (2 (if #f #f 1))
                             (else #t))
                           (cond ((if #t #t #\虜) #t) (else #\輯)))
                          (2 #f)
                          ((cond
                             (#t
                              (cond
                                (-1 #\U000F8058)
                                (#\㋠ -65)
                                (#f #f)
                                (#\U0010321A #t)
                                (#\斖 #\ᔉ)
                                (#\㶣 #f)
                                (260 #t)
                                (#t #t)
                                (#t #\䓷)
                                (#\漣 #\U00048726)
                                (#\⪐ #t)
                                (else -1)))
                             (else #\U000FB06A))
                           #\U0007DE56)
                          (else (- (if #f #\u0881 #t)))))
                       ((if #\U00062C0A
                            (if #f (cond (#t #t) (-1 #\戇) (else #\U0008C6EF)) 0)
                            #\U000A7FF4)
                        (if (if (cond (#t -1) (#t #t) (#f 2) (#f #f) (else 1))
                                (if -2 #\떃 #f)
                                (cond
                                  (#f #\U000EA648)
                                  (2 #t)
                                  (#f #t)
                                  (#f 18)
                                  (#t #\콽)
                                  (1 #\U000D8260)
                                  (#f #f)
                                  (#\陌 -64)
                                  (#\U000E724E -5)
                                  (else #f)))
                            (integer? (char? #f))
                            #t))
                       (else #\ら)))))
            -3))
         ((let ((c1 #\䜭)) #\U00040490)
          (let ((y2
                 (if #\U0001FB7D
                     #f
                     (cond
                       ((cond
                          (#\U00048302 #t)
                          ((if (if #\𧅙 2 4) #\U00047EE8 #f) #\U000AA2CE)
                          (#t #t)
                          (#f
                           (cond
                             ((cond (else #t)) (if 3 #f #\U000A6BBF))
                             (1 (if #f #\U00044907 #t))
                             (else #\𢳿)))
                          (#\镜 (if (sub1 #\U0008D2ED) #t #\U000D0E9B))
                          ((if #t (zero? #f) #t)
                           (cond
                             ((if #f #\쓍 -4)
                              (cond
                                (#t #t)
                                (#f -1)
                                (#t #f)
                                (#f #t)
                                (5 #\绵)
                                (1 #f)
                                (4 #t)
                                (else #\两)))
                             ((cond
                                (#\⩀ #\藍)
                                (#f #\땋)
                                (1 19)
                                (4 #\쀙)
                                (-2 #f)
                                (1 -2)
                                (#f #t)
                                (4 #\uA7E5)
                                (else #f))
                              #\U00077860)
                             (else
                              (cond
                                (#f #t)
                                (#f -8)
                                (#\𩟈 #f)
                                (#t #f)
                                (-4 #\蠐)
                                (6 #f)
                                (#f #\副)
                                (#f #f)
                                (else 2)))))
                          (-2 #t)
                          (#f #t)
                          (else #t))
                        #f)
                       ((if #t #\U0010AA50 #f) #\ꄳ)
                       ((if (integer? (char? #t)) #f #\쾹) (zero? (abs #f)))
                       (-3 -1)
                       (3 #t)
                       (else -9)))))
            #\楪))
         (else #\U000D0C04))))
    #f
    (let ((j0 2)) (add1 (add1 (let ((g2 #t)) #f))))
    (if (cond ((if #t #f #\U000BC509) #f) (else #t))
        (let ((g1 #f)) #t)
        (cond
          (#t (if #t (zero? -1) (let ((e2 -4)) e2)))
          (#f
           (cond
             ((char?
               (if #f
                   #f
                   (if -4
                       (cond
                         (#t #f)
                         (#f #f)
                         (#\U00095CC1 #\U000C7C1B)
                         (#f #\ᕩ)
                         (4 #f)
                         (0 -1)
                         (else #\U000D3AE1))
                       32)))
              (if #f
                  (cond
                    (else
                     (cond
                       (#f #t)
                       (#\u0CDB #t)
                       (0 #\U000CCF18)
                       (#\䵃 #\䄵)
                       (#\U000EF5B6 (abs #f))
                       ((cond
                          ((cond
                             (#t 2)
                             (#t #\U000902F1)
                             (#f #f)
                             (#\U00064170 #t)
                             (#f #f)
                             (#f #f)
                             (#\恀 2)
                             (#\U00056FEC #\U00051D47)
                             (#\U000F9C74 #f)
                             (#f -5)
                             (-1 #t)
                             (#t -2)
                             (#\秭 #\ẗ)
                             (else #t))
                           7)
                          (else (cond (#t -2) (else -1))))
                        (cond
                          ((if #f -18 #\잧) (char->integer #f))
                          ((if #t #t #t) #f)
                          ((cond (#t #\Ⴉ) (#t #t) (#f -1) (#f #f) (#\둹 #f) (else -3))
                           (if #\U00032844 -2 #f))
                          ((if #\U000C6361 #f 1) (if #f #\U000836A0 -32))
                          (else (integer->char #f))))
                       (else (cond ((- #\U0004AC7B) #\U000A9796) (else #f))))))
                  (cond
                    ((char->integer
                      (cond (#\窂 (cond (else #f))) (else (if #\𡿖 #f #t))))
                     #t)
                    (#t #t)
                    (#f -4)
                    (else #\貪))))
             (else (if #\U00100966 #\줹 #f))))
          ((if (cond
                 (#t
                  (cond
                    ((add1 (cond (else #\㚳))) #\몫)
                    (#t (integer->char (abs #t)))
                    (#f (if #\븫 (if #t -6 16) #t))
                    ((cond (else #t)) #\U0003ACEC)
                    (else
                     (cond
                       ((if #f 1 #\U0008E911) (cond (else #t)))
                       (-2 #\U000E641F)
                       (-1 #\U00018E95)
                       (#f #t)
                       ((if -19 #f #t) #t)
                       (#\褯
                        (cond
                          (#t #\ㅒ)
                          (3 0)
                          (#f #\䒚)
                          (#\ㅄ #t)
                          (#t #\U000F8E5D)
                          (#t #t)
                          (-2 #t)
                          (#\U0004C229 #f)
                          (5 #t)
                          (else #f)))
                       (#t (if #t #t #t))
                       (2 (char? #f))
                       (else (zero? #f))))))
                 ((boolean? (if 2 (zero? 1) #t)) #t)
                 (else (if #\糣 (if -2 (if #t #\u07BE #\U000DE95C) #f) #\𥤑)))
               (cond (-5 (cond (else #\땐))) (#t #\쿓) (else -66))
               -1)
           (cond (else #\U0001B683)))
          ((if #t (let ((n1 #t)) #\U00104A53) (let ((b2 3)) #t))
           (let ((c1 (boolean? #f))) (if #\U00036E0B 4 c1)))
          ((cond
             ((if #\U000CA9DA #t #\깝)
              (if #\U0001C1DC (if (if -4 #f #t) (integer->char -1) #f) 2))
             ((if #f
                  (cond
                    ((cond (2 #f) (else #\腹)) (abs #f))
                    ((cond (#f #f) (else #t)) 1)
                    (else (if #f #\쒚 #t)))
                  -1)
              (if (cond (else #f))
                  #f
                  (cond
                    ((if #t #f #\u0BAC) #f)
                    (5 #t)
                    ((cond (#f #f) (1 #t) (else #\跆)) (sub1 #t))
                    (else #\U0009BB6D))))
             (#f -2)
             (#f (cond (else #f)))
             ((cond (else #t)) #f)
             (#t (sub1 -3))
             (else #f))
           #f)
          (else (if #\𠝀 (if (if (if #f -1 #t) #f -4) #\䒉 #f) #f))))
    #t
    #t
    (cond (else (cond (#\夁 #f) (else #t))))
    (cond
      (#\ꠦ
       (if (cond
             (#t (boolean? #t))
             (#t (cond (else -1)))
             (#\U000EEBE9 0)
             (else (cond (else #\⚸))))
           (abs (if 3 #\絬 #t))
           2))
      (-3 (zero? 7))
      (else
       (if #t
           #\Ꞧ
           (if (char->integer 1)
               #t
               (cond
                 (#t #t)
                 (#t #\ⰴ)
                 (#f #f)
                 (-3 0)
                 (-1 2)
                 (#t #\U00059FF0)
                 (#f #\푍)
                 (2 #f)
                 (#\U000A629B #\U00092C95)
                 (else 7))))))
    #\U0006B0D3
    3
    (let ((w0 #f))
      (let ((e1 (let ((n2 w0)) (let ((r2 n2)) #\溃)))) #\U00065D9B))
    (let ((u2 #\U000380C8)) -3)
    #\U000F8AC6
    #t
    (cond
      ((if #f
           #\⅌
           (if (cond
                 ((abs #\諃) (cond (-5 #t) (#f #t) (#\覎 16) (#t #f) (else #f)))
                 (#f #f)
                 ((cond
                    (-2 #t)
                    (#\ꯋ -3)
                    (1 #t)
                    (-3 #\귛)
                    (-1 #\蔯)
                    (#\쑎 #f)
                    (else #t))
                  (cond
                    (#f #t)
                    (#f #t)
                    (#t -2)
                    (#t #f)
                    (#\U00092F6D 34)
                    (0 #f)
                    (else -3)))
                 (else #t))
               #\U0001D25B
               #f))
       #\⿊)
      ((cond
         ((add1 #\U000DE115) 2)
         ((let ((h1 (cond (else #t)))) #\U0010EFA3) #t)
         (#t
          (zero?
           (cond
             (#\U000E3EEB #t)
             (#\uABBE (abs #\汱))
             (#f -2)
             (#f -2)
             (-3 #t)
             (#t (sub1 7))
             (else #t))))
         ((cond
            (#f (let ((e1 -4)) 1))
            ((zero? -2) (let ((y0 2)) #\牾))
            ((cond
               ((if (if (if -1 -2 #f) #t 1) #f (char->integer (- #f))) -1)
               (else
                (if #f
                    (cond
                      (#f #\U0006E43B)
                      (#\U000FB7AB (cond (else #f)))
                      (#f 7)
                      ((integer? 2) #\괂)
                      ((cond (else -4)) (char->integer -2))
                      (-5 #t)
                      (#f #t)
                      (else
                       (cond
                         (#t #\䯍)
                         (#f #\桊)
                         (#\룙 #t)
                         (#t #f)
                         (#f #t)
                         (#\堔 1)
                         (#f -2)
                         (#t #t)
                         (else #\㶆))))
                    8)))
             (if #t #\ꈚ 2))
            ((if #\U000DBEC3 #t #\⍷) -4)
            ((if #t #t #\澆) 2)
            (#\콀 #t)
            (#t (cond (#f 1) (#\쌻 #f) (else 6)))
            (#t 0)
            (#t (- #t))
            (else (zero? 2)))
          (cond
            (#f #f)
            ((cond
               (#t #t)
               (-10 2)
               ((integer? (integer? (char->integer (boolean? -4)))) #f)
               (-1 #f)
               (#f #f)
               (#\勓 #\嘝)
               (else #f))
             #\U000467CC)
            (-2 #\걖)
            ((sub1 #f) #t)
            (else
             (cond
               (#f
                (-
                 (if #t
                     (if (if #f #f -5) (char->integer #\U000384EE) (zero? -17))
                     #\U00079456)))
               ((cond
                  ((char? (cond (else #t))) 2)
                  (#f 1)
                  (#t (boolean? (if (- #t) -1 #f)))
                  ((if (if #\ʘ #f -5)
                       (if #t
                           (cond (1 #t) (#\U000FA3AC #t) (#\␅ #t) (#t 0) (else #f))
                           (cond (#\♿ #f) (#t #\⏎) (#t #t) (#\দ #\⏪) (else -2)))
                       #f)
                   4)
                  (5 #f)
                  ((cond
                     ((cond
                        (-2 (if #\忽 #t 9))
                        (#t (if #t -17 #f))
                        (else (cond (#\鎮 #t) (else #t))))
                      (if (if #\𢍏 #f #t) (if #f #\䮋 #t) #f))
                     (#f
                      (if 1
                          (cond (#\靤 #f) (-2 #t) (#\𤔓 #\傳) (#\U0010A1B1 -9) (else -2))
                          #f))
                     ((if (if #f #f #\촞) 4 (if #f #\U000FE8DF #t)) 2)
                     (-4 #t)
                     (else -3))
                   (- #f))
                  (-1 #t)
                  (#t
                   (abs
                    (-
                     (cond
                       (#t 4)
                       (#f #f)
                       (#f -2)
                       (#t -1)
                       (#t #\U00068ADF)
                       (else #\㯕)))))
                  (#\샯 #t)
                  (2 8)
                  ((if (add1 #f) #f 1) #t)
                  ((cond (#t #f) (else #t)) -2)
                  ((if (cond
                         (-6 #f)
                         ((char->integer #\U00098096) #t)
                         ((cond
                            (#t #t)
                            (#t #\❭)
                            (#f -1)
                            (#t #t)
                            (-2 #f)
                            (#f #f)
                            (-4 #f)
                            (#f #f)
                            (#\U0006D8C9 #t)
                            (#t #f)
                            (else #f))
                          (cond (#f #\U0010E162) (else #\U0009D929)))
                         (else #\U0005445D))
                       #f
                       (if #t #f #\宱))
                   #t)
                  ((if #f (char->integer (boolean? 5)) -32) 1)
                  (else #f))
                #t)
               (5 #\䝞)
               (#t #t)
               ((cond
                  (-19 (if (boolean? #f) 2 #\ᡉ))
                  ((char? (integer->char #f)) #f)
                  (#f -2)
                  (#f #t)
                  (else (zero? #f)))
                -1)
               (else #\U00074D9C)))))
         (#f (if #t #t (let ((q2 #f)) #f)))
         (else 2))
       (cond
         (#\U000F538F #\U000C7A3E)
         (else (let ((r2 (cond (-7 -2) (else #\竗)))) #\U000F0EA1))))
      (#f #f)
      (#\ᾋ
       (cond
         (#t #t)
         ((if #f #\䴙 #t) (cond (-1 #t) (7 #t) (#t (let ((q2 2)) #\䳵)) (else #f)))
         ((zero? #f) #f)
         ((if #t 1 #\ၡ) -2)
         (#f #f)
         (#f #t)
         (else #\U00030CE3)))
      (#t 0)
      ((let ((w2 (integer? (integer->char #t)))) (let ((o1 (if #f w2 w2))) #t))
       (cond
         ((cond
            (#t (let ((r0 #\傋)) r0))
            ((cond
               (#\마 #t)
               (#f (if #\퓹 0 (char? (char? #\킊))))
               (#t 16)
               (-1 2)
               ((integer->char -1) -1)
               (2 #\𪞱)
               ((if (if 11 #f #\U000EF2DB) #f #\닦) -4)
               (#t -6)
               (#\煛 -4)
               (#\〨 #t)
               ((if (if (cond (#t (if #\⣍ -3 4)) (#f (add1 #t)) (else #\U000C46ED))
                        #t
                        (if #\U00033B4E
                            (cond (#\儤 1) (#t 3) (-3 #f) (else #f))
                            (add1 7)))
                    (cond
                      ((if -4
                           (cond
                             (16 #\暖)
                             (#t #t)
                             (-4 8)
                             (#\塖 #\U000C311A)
                             (-1 #f)
                             (else #f))
                           #\U000D8640)
                       #f)
                      ((sub1 (char->integer #\U00074D31)) #t)
                      ((if #t (if #f #f #f) #t) #\U000CDAEE)
                      (else #t))
                    #\鏵)
                #\䨌)
               (#t #\⎲)
               (-3 #t)
               (4 #\Ψ)
               (else #t))
             #t)
            ((cond (#f #\U0004C8C9) (else (- #\U000792AB)))
             (let ((b0 #\U00047203)) #t))
            ((if #\𫋏 #\U000496ED #f) (abs #f))
            (else #\潒))
          #t)
         (0
          (cond
            ((cond (#f -1) (else #\U000347A5))
             (cond (-6 #f) (#\矷 #f) (#t -1) (else #f)))
            ((integer->char -5) (cond (#t #f) (else 4)))
            (-1 2)
            ((boolean? 3) #t)
            ((if #f -2 #\ᒈ) (let ((i0 -17)) #f))
            (#f #f)
            (5 -1)
            (#t (if #f #\U00083A54 #t))
            (#f (if #\≛ -4 #\⭬))
            ((cond
               ((cond
                  (else (char? (cond (#\㥤 (if -1 #\峦 #\U00078C8A)) (else #t)))))
                #f)
               (#\㔣 #t)
               (#f #f)
               (#t #\咾)
               (#t 1)
               (#t #f)
               (-5 2)
               ((add1 (zero? -4))
                (if #t
                    (cond ((char->integer #\U0009E269) #\悝) (#t #t) (else #f))
                    #t))
               (else #t))
             #f)
            (#f
             (cond
               (#t #t)
               ((add1 #t) #t)
               (else (cond (else (if #\u12C6 #\U000D4D6A (add1 #t)))))))
            (#t
             (cond
               (#t (integer? (char->integer (if (cond (else #f)) (char? #f) #\川))))
               (17
                (cond
                  (#f (zero? (if #\뇆 #\U000B8675 #f)))
                  (#t #t)
                  ((abs 1) 8)
                  (-1 (if #\U00036DBA #f #t))
                  ((cond
                     ((cond
                        ((cond (1 1) (#f #f) (#f #\U00108F4C) (else #\ꄊ)) #t)
                        (else #t))
                      -1)
                     (#f -3)
                     (#f #t)
                     (#f
                      (if (cond (else #f))
                          (cond
                            (#t #t)
                            (#\U00083255 #f)
                            (-20 #\㪵)
                            (#\U000DC7CB #f)
                            (#\U0005A841 #t)
                            (else #t))
                          (if #t #\븡 -1)))
                     (else #f))
                   -5)
                  ((cond
                     (#t #t)
                     ((zero? (if #t 1 -2)) -4)
                     (-2
                      (cond
                        (#\U000C7D0C #\䦈)
                        (#f #\U000C647B)
                        (#\U000778AA #t)
                        (else -1)))
                     ((abs -2) #t)
                     (else -8))
                   -5)
                  (#t #\U000C3E19)
                  (-16 (cond (else #\U0007D9FF)))
                  (#\⍆ #t)
                  (else -1)))
               (-1 #\u0864)
               (else #\U00098233)))
            (#f #\늏)
            ((let ((z1 4)) #t) #\U0007FE7F)
            (#f #\맜)
            (2 #t)
            (#t #f)
            (else #f)))
         ((let ((h2 (if #f 0 #\扼))) #\U00098EB9) #t)
         ((if (if #\뉐 #t #t)
              (cond
                (#f (sub1 #f))
                (#t (boolean? (- #\ꑑ)))
                ((if #t
                     (if (cond
                           (#t #f)
                           (2 #\U0002D46B)
                           (#f #\U000FC72E)
                           (#f #f)
                           (#\◮ -18)
                           (else #\U000DF87D))
                         (cond
                           (#\삝 #\U00073E86)
                           (3 #f)
                           (#\U0003D20A 16)
                           (2 -2)
                           (else 2))
                         #f)
                     #f)
                 (cond
                   ((cond (else #t)) (if #f (cond (5 #t) (else #\U0006A4E7)) #t))
                   (else -1)))
                (else #f))
              (if 1 #t #f))
          (cond
            (#\U000B280B #\ٗ)
            ((let ((m0 #\筘)) -2) (if #\葮 2 #f))
            (#t #t)
            (else #f)))
         (else (- (if -2 #\烸 #f)))))
      (else (let ((h1 #f)) (let ((p0 3)) (if -1 #\U0004BF2B p0)))))
    #t
    (if 1 #f (if (abs 3) #t #\갚))
    (abs -3)
    #f
    (char->integer (add1 #f))
    (if -2 #t (let ((q1 -1)) (if #f #t q1)))
    (integer->char (cond (else #\U0005D90E)))
    #t
    #t
    (if #f -1 (if (boolean? -1) #f (- (if #\U000B6802 #t #t))))
    2
    8
    (if (cond
          (-2 (let ((t0 #t)) #f))
          (#t (let ((h0 #t)) #t))
          (-3 #t)
          ((zero? #t)
           (if (cond
                 (#\慲 #f)
                 (-4 -3)
                 (#t #\U00049574)
                 (#\錜 #\U000EB40A)
                 (#\ꖸ #t)
                 (32
                  (if 4
                      (if (cond (1 1) (#\ᬞ -8) ((abs #f) #t) (else #t))
                          (if 2 (add1 5) -1)
                          -1)
                      #\उ))
                 (else (cond (#\U000E3698 4) (8 (- (add1 #t))) (else #f))))
               (if 16 #\U000ECC14 -5)
               #f))
          ((if (if #t #f #t) (add1 1) #\𠬗) #f)
          ((boolean?
            (if (sub1 (if (if #t #\U000CE4E2 #\暌) (zero? #t) 0)) #t #\囝))
           #f)
          (#t #\㠴)
          ((zero? (if (- -3) (if #f (abs #\U00099289) #\U0008EABC) #f)) 0)
          (#f #\𤐔)
          (else (if #t (let ((k2 #t)) 4) (cond (else #\臚)))))
        (char->integer #f)
        #t)
    #f
    (if #\磖 #\U000CB7C1 -1)
    (if #f 4 #f)
    (cond
      ((if #f
           (cond
             (#f
              (cond (#f #f) (#f #t) (#t #f) (#t #\❨) (#f #\U000E8EA7) (else -1)))
             ((cond (#\U000B76FC -3) (else #f))
              (cond
                (#t #\U00015E4F)
                ((abs 1) 2)
                (#\U000ABF36 #t)
                (#\U000CC657 #\U000A6BCF)
                (#\U0008D651 #f)
                (5 2)
                (#\U000A7522 #f)
                (#\U000BD682 #\远)
                (#t #t)
                (#\U0001468D #\U00017396)
                (#f #\U0006BAA9)
                ((cond
                   (#\U00107A6F #t)
                   (-2 (if #t (if #\ᱤ #t #f) #\U0003B513))
                   (else #\U000B7E72))
                 #\쑮)
                (#t #t)
                (#f 1)
                ((integer->char #t) #t)
                (#t #t)
                (-1
                 (abs
                  (cond
                    (#\U000E0F33 #t)
                    (-2 -1)
                    (#t (if (char->integer #t) (zero? #t) (char->integer #t)))
                    (#\U00088DC0
                     (cond
                       ((char? #f) (if #\媼 #f #\U00046C7E))
                       ((abs #f) #f)
                       (#\U000BB1D4 (cond (else #f)))
                       (else #f)))
                    ((sub1 (if #f #\쾮 #f)) (zero? #f))
                    (#t (integer->char (integer->char #t)))
                    (#f (if (zero? #f) (char->integer -4) #f))
                    (-4 (if (abs 3) (cond (#\뿛 #f) (else -3)) (if #t -1 #f)))
                    ((char->integer (cond (#f -2) (#t #\U0008B6AE) (else #f)))
                     (if #f -2 #t))
                    (else -4))))
                (#\𧯭 (cond (else 2)))
                (else 1)))
             ((if #t #f #t) #\U000CC486)
             ((integer? #t) #\慾)
             (else (cond (else 0))))
           -2)
       #t)
      ((- #f) #t)
      (else #t))
    #\䅝
    #f
    (if 2
        (if (integer? 3)
            (cond
              (#\U000D3EBA (let ((z0 #f)) z0))
              (#f (if -4 #f #\ꧤ))
              ((cond
                 (-4 #f)
                 (#\u0010 #t)
                 (#t 6)
                 (#t #\U000BF5EA)
                 (#t 1)
                 (#f 5)
                 (#t #\U00040977)
                 (#\쟑 #\U0007CA8C)
                 (else 4))
               #\U0002F07B)
              (else #\㴷))
            #f)
        #f)
    #\U0010EA52
    (let ((o1 #\妄)) #f)
    (let ((m1 (zero? #\U0003B522))) #\U00047C12)
    #f
    (-
     (let ((e2 (let ((w2 (cond (else -1)))) (let ((s1 1)) w2))))
       (cond
         ((if #\흦 #\骭 16) #\U000F6428)
         (#t
          (cond
            (e2 e2)
            (-4 #t)
            (#\𨖻 e2)
            (e2 #f)
            (#t #\U00072517)
            (e2 #\U00068A5A)
            (#t -1)
            (e2 -3)
            (#f 4)
            (else #\ᙆ)))
         (else (let ((u0 e2)) #t)))))
    #\擼
    3
    (if (let ((k0 (char? #\U00019CAF))) #f)
        (cond (else #\U000903D9))
        (char->integer
         (cond
           (#\U000D7F66 #t)
           ((char? #f) (let ((h0 #f)) #\U0009294F))
           (-8 (if #f #t #t))
           ((cond (#t #f) (#\䊈 2) (else #t)) (abs #f))
           (else (add1 #t)))))
    (cond
      ((let ((z0 #f)) 5) (abs #t))
      (#t #\U00063D18)
      ((let ((a2 #f)) a2) (char? (if #t #\몼 #t)))
      (2 (char? (cond (else -2))))
      (-2 #\죎)
      (20 #\愰)
      ((cond (else -5))
       (if (let ((d2 (if #\౭ #f #t))) #f)
           (cond (-1 (integer? #t)) (#f #f) (else #t))
           #f))
      (-1 (let ((p0 (if 16 #t (if #t #\𠐟 #\U000171B3)))) p0))
      ((if (cond
             (#f
              (cond
                ((if #t
                     #t
                     (cond
                       (#\U000C3C28 #t)
                       (#\𪈦 (if 1 -1 4))
                       ((if #\U0008CD92 #f #f) -3)
                       (#\駨 #t)
                       ((char->integer #\㳕) (zero? #f))
                       ((cond
                          (5 #f)
                          (#t #\癟)
                          (-3 #t)
                          (#\U000D3B07 #t)
                          (#t #f)
                          (#t #\U000BBEA7)
                          (2 #t)
                          (#f #f)
                          (#\㋛ #t)
                          (#t #t)
                          (#\㼁 #f)
                          (#f #t)
                          (#\U0009E93D #\䅥)
                          (#f 1)
                          (#t #t)
                          (else #t))
                        #f)
                       (1 -5)
                       (#t
                        (cond
                          (#t #t)
                          (#t #f)
                          (#t #f)
                          (#t #t)
                          (#\Ⅱ 65)
                          (-6 0)
                          (#\U000E3811 6)
                          (#\𧣋 #f)
                          (0 #t)
                          (#t #\嬉)
                          (8 #\U00087878)
                          (#t #\㠃)
                          (#\U00019875 1)
                          (#\U0006CCCD #f)
                          (#t #t)
                          (#\U0002F4C3 5)
                          (#t 2)
                          (else #f)))
                       (#f #\褻)
                       (#t (if #t #t #f))
                       (else (integer->char #\錊))))
                 (if (if #t (cond (else #\U0007303C)) #\U0007D344)
                     3
                     (add1 (if -5 #t #f))))
                ((if #\U00078362 (abs (if -1 #f 2)) 1) -4)
                (#f (char->integer #f))
                (8 #f)
                (else
                 (cond
                   ((boolean? #\䤿) -4)
                   (-1 (if 1 (cond (-1 -3) (#t #t) (-2 3) (else #f)) 1))
                   (else (add1 2))))))
             ((cond ((zero? #t) #t) (else #f)) -2)
             (else -2))
           (if #t #\U000617BD #\뾬)
           (char? -2))
       -9)
      (8 #\轇)
      (#\젗
       (if #\U000C1865
           (cond
             (#f #\U0009B736)
             (#f #\Ẓ)
             (#\餻 (char->integer #f))
             (#\U000F2F07 (let ((a1 #f)) #f))
             ((if (if #t 18 2) #t #t) #\U000C7AFE)
             (#t #t)
             (else (integer? #f)))
           (if #t
               (-
                (cond
                  (#t (if (integer->char (cond (else #t))) #t (boolean? -5)))
                  ((if #f (cond (#t #t) (else -1)) (add1 (add1 #f))) -1)
                  (#\梔 #\U000B8B5F)
                  ((if (if (cond
                             (#t -1)
                             (2 #\U000DC968)
                             (#\U00039890 #\U000DDB36)
                             (#f #\U0004DE63)
                             (#f 1)
                             (#\㮭 #t)
                             (else #f))
                           #f
                           (- #t))
                       #f
                       (cond (else #\㾼)))
                   (cond
                     (#f #\U000F1796)
                     ((if #f (add1 #t) #t) (cond (2 #f) (else #\𤹋)))
                     ((integer->char (integer? -8)) #\U000E18D6)
                     ((cond
                        (-18 (if 1 3 -19))
                        (0 #\U00060897)
                        (#\臇 (if #t #\U0009618D -4))
                        (else 1))
                      #f)
                     (#t (add1 (if #\U001010CA 3 -2)))
                     (#\Ã #\ꚍ)
                     (2 -2)
                     ((- #f) (abs #t))
                     ((if #t #t (cond (#f #t) (else 3))) #t)
                     ((cond
                        (8 (add1 #t))
                        (#t (add1 #t))
                        (-2 (sub1 -2))
                        (#t #f)
                        (2 (cond (#t #\䒋) (-2 #f) (else #t)))
                        (#f (sub1 -6))
                        (#\U00043EFA #f)
                        (else (- #f)))
                      #f)
                     (9
                      (if (cond (#f #\U00034345) (5 #t) (#t -1) (else #\蕜))
                          (cond (#t #f) (#f #t) (#\U00090495 #t) (else -1))
                          (char->integer #t)))
                     (#\侂 (zero? -1))
                     ((cond
                        ((if #\ⴗ #f #t) (cond (else #f)))
                        ((if #\U0007F9E3 #f 2) (cond (else #f)))
                        (2 #t)
                        (1 (if #\𥢓 #f #\҃))
                        ((if #f #t 32)
                         (cond
                           (#f #\조)
                           (#t #t)
                           (#\ᚼ #\U000F0549)
                           (-33 #\U000712D9)
                           (else #f)))
                        ((cond (#f #\ꈤ) (#f 4) (#f -5) (#t #\矀) (else -9))
                         (cond (#t #f) (#f -1) (1 #\U000A6ACE) (#f #\叮) (else 2)))
                        (#f #\불)
                        (#\U000AB03C #f)
                        ((if #\U00034BB9 #t #\䠪) -3)
                        (#f #t)
                        ((cond (else #f))
                         (cond
                           (#t #f)
                           (#t #f)
                           (#f #t)
                           (5 #f)
                           (#\U000A2DC1 #t)
                           (else 3)))
                        (#\玑 #\u0DD5)
                        (#f #t)
                        ((if #t #f #\팟) -1)
                        (else (integer->char 1)))
                      (cond (#t #\U0005BD21) (else (if #f #t -1))))
                     (else
                      (cond
                        (#t (char->integer #t))
                        (#\U000E2B8A (integer? #t))
                        (#t #t)
                        (4 (cond (else #f)))
                        (else (cond (else 12)))))))
                  (else 1)))
               #t)))
      ((if #f #\U0009E864 #t) (let ((h0 #t)) -4))
      (#\U0009DB85 #\夣)
      ((cond (else -7)) (let ((j2 (cond (else (let ((s1 #t)) #\𠗐))))) #f))
      ((cond (#f #t) (#f #f) (else (let ((q0 -8)) (integer->char #\❨))))
       (cond
         (#\쐑 #\U0009B988)
         ((- (char? #t))
          (-
           (cond
             ((if (integer->char #t) #\U000E3BC7 #t)
              (if (integer->char #f) (if #\U000860E7 #t 3) (integer->char #\䉩)))
             (else (abs (if #\U000EC577 #f #t))))))
         (#t 2)
         ((if (let ((e2
                     (cond
                       (#t (if (zero? #t) (char->integer -4) #t))
                       ((abs 3) (add1 #\U000D5BE2))
                       ((if (if #f #f (char->integer #t))
                            (cond ((add1 #\넃) 5) (else (if #f #f #f)))
                            (cond
                              (#\U000988FB #\u088D)
                              (#f #\䜀)
                              ((if #f #t -4) #t)
                              (#t #f)
                              (else #f)))
                        #f)
                       ((boolean? #\U0004594D) (if #f 20 #\U000CEACF))
                       (else #f))))
                3)
              #f
              #\U000B1D8D)
          #t)
         ((boolean? (let ((m2 #t)) m2)) (zero? #\籱))
         (#\𣪆 #\U00032865)
         (#t
          (cond
            ((cond
               (#f 64)
               ((zero? (integer? (cond (#f #t) (#\벖 #t) (else #\曊)))) #t)
               (#t #\⪐)
               (else #t))
             #\U000F154B)
            ((cond (9 (zero? #f)) (-1 2) (#f #\㞟) (#t #\U000AB733) (else #t))
             (if -9 #t #f))
            (else #\U000A5341)))
         ((cond
            ((cond (else 3)) #f)
            ((char? #\މ) (sub1 #f))
            (#\U00106577 -8)
            (#f #f)
            ((cond
               (#t #\🎾)
               (-32 #t)
               ((char->integer #f) (if #t (sub1 -2) #\ᰨ))
               (else (cond (3 #\ҭ) (#f -1) (else #f))))
             (if (if (- -4) #f (if #t 1 #\U0010AE73)) (- #\U000F5EE7) #t))
            (#\U0004960F (- #t))
            (#f
             (cond
               (#\U000E9083 #\U000E6244)
               ((if (if #f #f #\U00056E8C) #f #f) #t)
               (#\U0003680F (abs (zero? #t)))
               (#\U000B24F9 (cond (#\𩃛 (cond (else -2))) (else #\U0005FA11)))
               (#t -2)
               ((if (cond
                      (#t #\픧)
                      (#t #t)
                      (1 4)
                      (#f #t)
                      (4 #f)
                      (#f -1)
                      (#f #f)
                      (-4 -4)
                      (else 1))
                    #t
                    1)
                #\U000E476B)
               (#t #t)
               (#f (if #t #f #\鲦))
               ((if (boolean? #f) #f (if #\豹 -2 #f)) 0)
               (#f (if -2 #\u2E6C #t))
               (else #t)))
            ((- #f) (boolean? #\U00095CA3))
            (20
             (cond
               ((boolean? (integer? #\퍃)) #\륺)
               ((if #\U0003245B #f (sub1 #f)) #t)
               (#f -3)
               (#\U00014BCF (if #\U00065E14 #t 1))
               (#t (char->integer (if #f #\踢 #f)))
               (#f 1)
               ((if #f (if 1 #t 1) (if #t #f 2)) (if #t -2 #\㭁))
               (#t -7)
               (#f #t)
               (#t
                (integer->char
                 (cond
                   (#t #f)
                   (#f #t)
                   (#t #t)
                   (-1 2)
                   (#f #t)
                   (#\U000E32B6 #t)
                   (#f #\U00057683)
                   (else #t))))
               ((cond
                  (0 #\ꖱ)
                  (#t #f)
                  ((cond (#f #\U000E225A) (8 #f) (3 #\了) (#t #t) (else #t))
                   (if #f #f #t))
                  (#t #f)
                  (#f #\U00083F8D)
                  (else (char? #\U000587DF)))
                #t)
               ((cond
                  (#t #\쌪)
                  (-4 (if 1 #f #t))
                  (#\⛰ #\U00108D43)
                  ((if #f -1 0) (zero? #t))
                  ((cond (#f #\U000A9008) (else #f)) #f)
                  ((cond
                     (#t #\䕅)
                     (-6 #f)
                     (-2 #f)
                     (#f #f)
                     (#t #\U0006B389)
                     (#t #\ᅦ)
                     (else -1))
                   (sub1 #f))
                  ((integer? #t) (add1 #t))
                  (#t 2)
                  ((if #t 2 #\罠) (if #f #f #f))
                  (3 #f)
                  (#f 2)
                  (#\訿 (boolean? #f))
                  (-4 (zero? #f))
                  (else 4))
                (add1 #f))
               (#t (abs #t))
               ((boolean?
                 (cond
                   (#\쥶 #t)
                   (#\온 #\팓)
                   (#\畭 #\U000E5FE3)
                   (1 1)
                   (#\U00014942 #t)
                   (#f 3)
                   (-2 #\U0009FFEA)
                   (else 11)))
                #t)
               (#\U000529A6 #f)
               (#\U00018335
                (cond
                  (#f (cond (#f -1) (#\够 #f) (#\U00080D2E -6) (#t #f) (else #t)))
                  (#t (if 4 #\U000EFBA5 #f))
                  (-4 (cond (#\㇡ -1) (#\U001024F4 #t) (#f #t) (else #t)))
                  (1 (zero? #\뱾))
                  (#t (if #f 0 -2))
                  (-1 -1)
                  ((if #t #\㲙 2) #f)
                  ((integer->char #f) (integer? #f))
                  (-5 -2)
                  ((cond (else #t)) (integer? #f))
                  ((cond
                     (#f #t)
                     (#\U000D5CAA #t)
                     (-1 0)
                     (#f #f)
                     (#f #t)
                     (#\빿 #t)
                     (#\𪵤 #t)
                     (-1 #f)
                     (#f #\U00036D87)
                     (#f -18)
                     (#t #f)
                     (else #t))
                   -2)
                  ((if #t -2 #t) (cond (#t -2) (#\U000ADC3D 2) (#t -10) (else #t)))
                  ((cond (else #\䑣)) (char->integer -1))
                  ((char->integer #\㲩) (integer? -4))
                  (-5 #t)
                  ((if #f #f #\U000316FA) 513)
                  (#f 2)
                  (else (if #\U000397E4 #t -2))))
               (#f #\錒)
               ((cond (else #t)) (if 1 (- #f) #f))
               ((if (abs #\U00041B65) #f (if #f #\𤤑 #\饉)) #t)
               (else #f)))
            ((integer->char (cond (else (integer->char #f)))) 1)
            (#\U000C5C87 #t)
            (#f
             (if (add1 (abs #t))
                 2
                 (if (if #\U00090ABF #f #f) (if #t #f -257) #\뚇)))
            (#\༶ (if #t (- #\U001003D3) 0))
            (1 8)
            ((integer? #t) #\U0010406B)
            ((if #t 0 #f) #f)
            (1 #\ዌ)
            (else #\U0009495E))
          (if (let ((f1 #t)) #\믩)
              (cond (#\U0005BCB1 #t) (else 0))
              (if #t #f #\⊞)))
         (#f (if #\U000DA25E -4 #f))
         (#f #\㺚)
         (else #t)))
      (#f
       (if #\甓
           (cond
             (#f (zero? #t))
             (1 #t)
             ((boolean? #\鳤) #f)
             ((if #t #f #t) (- 3))
             ((if #f -2 #f) (if #\綪 #\䋂 #\U0009F25E))
             (#f 1)
             ((let ((g1 #\U000F95B6)) 4) (- 0))
             ((cond (#f #\U000C3777) (#t -1) (else #t)) #\㕄)
             (#f #t)
             ((cond
                (#\U000B5FC9
                 (cond
                   (#\珅
                    (cond
                      ((if #\U000EA031 -3 (if #t #\U00011884 #\虗))
                       (cond
                         (#\U00094801 #t)
                         (#f
                          (cond
                            (-1 #\䱌)
                            (4 #t)
                            (3 #t)
                            (#f #f)
                            (#f #\䓉)
                            (11 #f)
                            (#f #t)
                            (#f #t)
                            (3 #f)
                            (else #f)))
                         (else (cond (else #\U0009189A)))))
                      ((cond
                         ((integer? 3) #t)
                         ((zero? #f) (if -1 #f #t))
                         (#f (if #t #\U000817C5 #\ύ))
                         (else #\U0009BF58))
                       #f)
                      (#\㭬 #t)
                      (#\𑋈 #f)
                      (#f (boolean? -1))
                      (3 #\司)
                      ((if -2 1 #f) #t)
                      ((cond (else #f)) #t)
                      ((zero? #f) #\ᡚ)
                      (#\U000B3DA5 #f)
                      (#f (cond (else #f)))
                      (#f (if #t -2 #f))
                      (3 #f)
                      (#f (zero? (if #t #t #f)))
                      (#f #\U00046758)
                      (else #t)))
                   ((if -1 #t #\ᆨ) 1)
                   (-2 5)
                   (else 1)))
                (else #f))
              #\밦)
             (else -2))
           #\U000BE13F))
      ((cond
         (-2 (if (if #t #f #t) #\U00108DC1 (cond (else #f))))
         (#t (let ((n1 (char->integer #t))) #t))
         (#t (if (zero? 2) (let ((h2 #\U000C82C7)) #f) (boolean? 2)))
         ((let ((n2 -4)) (let ((b1 #t)) 4)) #t)
         (else #t))
       (let ((q1 (let ((g1 (if #\侂 #f 7))) g1))) (sub1 #f)))
      (#\偫 #f)
      (else (let ((v0 1)) (let ((b1 #\U000F21E6)) (if #t #t #f)))))
    -4
    (if #\U0006BA2E (zero? #t) 0)
    1
    #\雿
    -3
    #\㮼
    #\ꙵ
    #\U0004887F
    (if #f
        (if #t
            (zero? (integer->char #t))
            (cond
              (16 #\莁)
              ((cond (#\U00104096 1) (#t #t) (33 #f) (#f 3) (#t #t) (else #t)) 1)
              (#f (let ((h2 #\U000E4358)) #\Ꝙ))
              (#f #t)
              (#f (add1 #f))
              (#t #t)
              ((let ((g0 #f)) 1) #f)
              (#t (if #t #\㔋 #t))
              (#t (if #\U00085B2C #\U000E24F7 #\U000B5090))
              (2 1)
              (else
               (cond
                 (#t #f)
                 (1 #f)
                 (#t 7)
                 (#\騽 #t)
                 (#t (sub1 #f))
                 (#t #\U000A6836)
                 (-4 #\U000D4111)
                 (#f
                  (cond
                    ((char? -4) (if #f -2 0))
                    ((- (cond (#\𣆕 5) (else #\ꓫ))) 4)
                    ((cond (else #f)) #\U0010129D)
                    (#f (if #t #t 4))
                    (#t #t)
                    ((if #f
                         (cond
                           (-5 (if #t #t #\ꦘ))
                           (#t (if 1 3 #t))
                           (#\슓 -7)
                           ((cond (-1 #f) (#t 2) (else 2)) #t)
                           ((if #\U000DA04B #t #t) #\鴭)
                           (#\첐 (cond (9 #f) (#f #f) (#f 1) (#t #\U000E41D7) (else #\𢟾)))
                           ((cond
                              (#f #f)
                              (#\ꄞ #t)
                              (#t #t)
                              (#f #\똜)
                              (#f #t)
                              (#f #f)
                              (#t #t)
                              (3 #\U000BFDAA)
                              (#f #f)
                              (#\鑖 #f)
                              (#t #\ޥ)
                              (else #f))
                            #\U00044B87)
                           ((cond
                              (#f 2)
                              (#t #f)
                              (#f #t)
                              (#\U000A95A1 #t)
                              (#\U000BA42C -4)
                              (#f #\U00018168)
                              (else #t))
                            #\Ὧ)
                           ((abs -2) (cond (#t #t) (#f #f) (#t #\U000D8A16) (else -258)))
                           (else (cond (else #t))))
                         (if 2 #t #\U000A60A4))
                     #t)
                    (#t (cond (-9 #f) (else #\U000DBB07)))
                    ((cond
                       (#f (if (if 1 #t #t) (if #\U00031A5A #t #t) 4))
                       (#\౧ #f)
                       (#t (boolean? #\뺈))
                       (#f (if -2 #t #f))
                       ((cond
                          (3 (abs #f))
                          ((char->integer -4) (cond (4 #\U0002F197) (#t -1) (else 0)))
                          ((cond (else #f)) #f)
                          ((integer->char #t) #f)
                          (#f (cond (#f #\U0002DE4B) (else -2)))
                          (#f (abs #f))
                          (#f (if #f 4 #\U0005D27B))
                          (else 2))
                        #\᳂)
                       ((cond
                          (4 2)
                          (#f #\U00049C88)
                          ((char? #f) -2)
                          ((cond
                             (#t #f)
                             (#\U000781ED #f)
                             (1 #t)
                             (#f #f)
                             (#t #t)
                             (-2 #f)
                             (#\쌐 #\씦)
                             (#f #t)
                             (#t #t)
                             (else 3))
                           1)
                          (#f (cond (#\㘺 1) (#\圏 #f) (-1 #f) (else #f)))
                          (#f 1)
                          ((if #\U0008642D #t #t) #f)
                          (#\习 #t)
                          (#f (cond (#t #f) (#f -6) (else -17)))
                          (#f (cond (#t #f) (else #t)))
                          ((cond
                             (#f #\뫑)
                             (1 -1)
                             (#\U00034677 -2)
                             (#\U00049732 #f)
                             (else #\U000D9274))
                           (if #t #f 2))
                          ((abs #f) (char? #\U0003F306))
                          (#\U00080015
                           (cond
                             (#\U0004B7F2 -3)
                             (#f #\U00099CDA)
                             (#f #\ᔏ)
                             (#f #\꺍)
                             (else #f)))
                          (else #f))
                        #t)
                       (#\U000F27EB #f)
                       ((cond ((if #\殍 #f #t) (char->integer #\鼤)) (else #t))
                        (cond (else #t)))
                       (#f #f)
                       (#t #f)
                       (#\U000F6B78 (boolean? #\캓))
                       (-1 #f)
                       (#f #t)
                       (#t #t)
                       (#t #f)
                       ((integer? #t) #t)
                       (#\U001051DD 13)
                       ((if #t (if #f #t #\U001083B2) 1) #f)
                       ((- (if #f -2 2)) (zero? #f))
                       (#t
                        (if (cond (#f -2) (#f #t) (-2 #f) (else -5))
                            #\U000DD565
                            (cond (#\U000E7EA8 #t) (#t #f) (else #\ꎏ))))
                       (#\뉕 (if #t #\U00076FFD 3))
                       ((cond
                          (#\枏 -4)
                          ((if #\U000A167D #f #f) (integer->char #\U000E0A5C))
                          (else #t))
                        #\U000DDEFB)
                       (else
                        (cond
                          (#t (cond (#f 2) (else #\U000654E1)))
                          ((cond
                             (#t #\颯)
                             (1 #t)
                             (#\滧 #\U00107D1A)
                             (2 #\U000332B7)
                             (else 2))
                           (if #\𠧧 #f #t))
                          (2 (- 5))
                          ((if #t #f #\넅) (if #t #t #\u18FC))
                          (#f (char? #f))
                          (#\U00048822 (if -1 -1 #f))
                          (1 #f)
                          (-4 (integer->char 2))
                          ((if #\U0006F98B #t #t) #f)
                          ((cond (-4 #\훢) (#t 1) (-4 #t) (#t -3) (else -3)) 8)
                          (else (cond (else 2))))))
                     (cond (else (cond (else (cond (else #t)))))))
                    ((- (if #f #t #t)) (sub1 #\U000DC51E))
                    (else (integer->char #t))))
                 (#f 130)
                 (#t #f)
                 (-8 #f)
                 (2 #f)
                 (#t 1)
                 (else #\U000B98B7)))))
        #f)
    (cond (else #t))
    #f
    -8
    #t
    (let ((u0 2)) (- #t))
    #t
    (if (char->integer 1) #\U000497F7 #t)
    (let ((o2 (let ((l0 #t)) (let ((c1 (let ((p1 #\𨑵)) 17))) #t))))
      #\U000518C9)
    #t
    (cond
      ((let ((a1 (if #\U0001DCF7 #t #f)))
         (if (if #\U0009607D #\仉 a1) #t (let ((c1 #t)) 5)))
       (let ((e2 (- #\U00062330))) #f))
      ((cond ((if #f #\㢙 #t) (abs (if -5 #f #\駌))) (else (let ((s0 #\ể)) -17)))
       (if 1 #f (integer? (let ((t1 #f)) t1))))
      (#t #t)
      (else (if #t #f (integer->char (let ((r0 -32)) #\䢨)))))
    #t
    (let ((l2
           (if (cond
                 (#f (cond (-2 9) (#\U000EB623 #t) (2 #t) (#f #f) (else #f)))
                 (else (if #\땣 #t 4)))
               -3
               #f)))
      (let ((y0 -3)) (let ((x1 (cond (y0 -4) (else #t)))) #t)))
    (let ((c0 (- (integer? #t))))
      (abs (if (integer? #\U0007C7BA) (integer? #\骨) (add1 #t))))
    (let ((b2 -4)) (let ((g0 #\U000BB3FA)) g0))
    #t
    #t
    #f
    #f
    (add1 #t)
    (integer->char (sub1 #f))
    (if #\韼 -1 #t)
    #\뵓
    (cond
      (1
       (cond
         (#f (add1 #t))
         (#f (let ((t1 (integer->char -8))) #f))
         ((zero? (if #\U0009C234 -4 #f)) -2)
         ((let ((r1
                 (cond
                   (2 #t)
                   (#t #f)
                   (-4
                    (cond
                      ((sub1 #t) (integer->char -4))
                      ((sub1 #\匮) #\U000342C1)
                      (9 (if #\珱 4 -4))
                      ((cond (#f (cond (else 1))) (else #f)) 7)
                      (else
                       (cond
                         ((char->integer (if 5 1 #\葬)) (zero? #t))
                         (#f #\௨)
                         ((cond
                            ((integer? #f)
                             (cond
                               (#\u0892 #\U00067BE4)
                               (#f #\齐)
                               (#f 2)
                               (#t #f)
                               (#\堟 #t)
                               (#t 5)
                               (4 #\浈)
                               (else #\़)))
                            ((abs #\U00084A75)
                             (cond
                               (#t #\瞩)
                               (#t -3)
                               (#f 7)
                               (#t #f)
                               (#\寤 3)
                               (#f #\U0003E12A)
                               (#\鱎 #\U000D47D5)
                               (#f #\풇)
                               (else #\홖)))
                            ((if #t #f #f) (add1 #t))
                            (-1 #t)
                            (else (char->integer #\旞)))
                          (char? 2))
                         ((zero? #\즨) 5)
                         ((abs (cond (else #t))) 2)
                         (#\U00105CB5 #t)
                         ((cond
                            (#f #\ᴁ)
                            (#f #f)
                            ((char->integer #t) #t)
                            (#t #t)
                            ((cond
                               (#t #f)
                               (#t #t)
                               (#\⡐ #f)
                               (#\ꜷ -3)
                               (#t #f)
                               (else -2))
                             4)
                            ((cond
                               (-3 #f)
                               (-3 #t)
                               (#t #\켞)
                               (#\U0003C795 #\췫)
                               (#t #f)
                               (#f 1)
                               (#f -2)
                               (#t -2)
                               (#\U000F8DF3 #\U000129CC)
                               (#t #f)
                               (#t #t)
                               (-2 #\呭)
                               (#f #f)
                               (-1 -16)
                               (#\U000F77D1 #f)
                               (#\U00083BF8 #f)
                               (#f #t)
                               (else -9))
                             #\렎)
                            (#f
                             (cond
                               (#t #f)
                               (16 #f)
                               (#f #t)
                               (#\釗 #f)
                               (#f #f)
                               (#\井 #t)
                               (#\U000E3A3B #f)
                               (#t #\讃)
                               (else #\䜓)))
                            ((cond (else 1))
                             (cond
                               (#\U000AF92D #f)
                               (#t #\칑)
                               (#t #\U00069753)
                               (else #f)))
                            (-1 (integer? #t))
                            (#t #f)
                            (else (char? -3)))
                          #\U0005E0FA)
                         (16
                          (cond
                            ((cond (-4 #\牗) (1 2) (#f #f) (#t #\U000323E2) (else -1))
                             #t)
                            (-10 1)
                            (#\躺 #f)
                            (#f #f)
                            (else #\䉙)))
                         ((if (integer->char #t) (if #t #f #f) (if #f #\ᒩ #f))
                          (cond
                            ((if 4 1 4) (integer? 0))
                            ((abs #\煦) 4)
                            (#\U0002B73F #t)
                            ((abs 0) #f)
                            (else #f)))
                         (3
                          (cond
                            (#\輪 (if #\ჾ #t #f))
                            ((if #\U000D7861 #f #\囙) #f)
                            ((cond
                               (-1 #t)
                               (#f #\랖)
                               (-2 #f)
                               (-3 -4)
                               (-4 #\㡲)
                               (3 #f)
                               (else #f))
                             #\焸)
                            ((integer? #t) #f)
                            (#t (cond (-5 -1) (#t 2) (else #t)))
                            (#f (- #t))
                            ((if #t #\♊ #\ꀏ) (if #t -2 #\Ꮴ))
                            (-1 #f)
                            ((if -2 #\㵬 #\U000B1B17) #f)
                            ((cond
                               (1 -2)
                               (-4 4)
                               (-1 #\U00099D05)
                               (#f #t)
                               (#f #t)
                               (#f -4)
                               (#\춨 #t)
                               (#t #f)
                               (8 #\U000654C8)
                               (-1 #f)
                               (#t #t)
                               (#t 2)
                               (else #f))
                             #t)
                            ((cond
                               (#t #\U00065A5B)
                               (#t #f)
                               (#\U0007E175 #f)
                               (else #\U0002CDAB))
                             (boolean? #\褑))
                            ((if #f 3 #t) #\U000F7371)
                            ((cond
                               (2 #t)
                               (#f #\ጪ)
                               (4 #t)
                               (#\殙 #f)
                               (#t #f)
                               (else #\媚))
                             (cond
                               (-1 #f)
                               (#\U0002D94A #f)
                               (#f #t)
                               (#t #\U000470DA)
                               (#\뛺 #f)
                               (8 #\쎑)
                               (#f #t)
                               (3 2)
                               (else #\÷)))
                            (#t 3)
                            (-4 -3)
                            (3 #\U0006E97B)
                            (else 2)))
                         (#\U0005DB17 (if #t #f (if #\U0005FF34 #f #f)))
                         ((cond
                            (#\uAB96 (if #\U00090C0C #t #\폚))
                            (#\U0007FBA5 #f)
                            (else #\U000B0AFE))
                          (integer->char #\꣗))
                         (-2 #f)
                         (#\⃔ #\⿳)
                         (#t (zero? #t))
                         ((cond
                            ((add1 #\照) (if #t #\U000AF513 -13))
                            (-4 (integer->char -3))
                            ((cond
                               (0 #t)
                               (2 #f)
                               (2 #\U00011540)
                               (#\uE85D #f)
                               (1 -1)
                               (#f #f)
                               (#\橿 -5)
                               (#f #f)
                               (#t #f)
                               (#f 3)
                               (#t 4)
                               (-2 #f)
                               (#f -1)
                               (4 3)
                               (else #f))
                             #f)
                            ((sub1 #f) (cond (else #f)))
                            (else (integer? #f)))
                          #t)
                         (#\U0005C6FC #\u2BBA)
                         ((add1 (- -4))
                          (cond
                            ((add1 -2)
                             (cond
                               (#\刪 #t)
                               (#\롇 #\U000306D2)
                               (#f #f)
                               (#\饥 128)
                               (3 #t)
                               (1 #f)
                               (else #\쏣)))
                            (else #f)))
                         (1
                          (sub1 (cond (#t #\镑) (#t #f) (-2 #t) (else #\U000980ED))))
                         ((sub1 #\᧚) (if #f (cond (else #t)) #\滊))
                         (#t (add1 0))
                         ((if (cond
                                (#f #t)
                                (#t #t)
                                (#f 1)
                                (#f #f)
                                (#f #t)
                                (#f #t)
                                (#f #\ኤ)
                                (#f #\U000E59BD)
                                (#f #\塬)
                                (#t #t)
                                (#t #f)
                                (1 #\U0004F267)
                                (#\U0008ED25 #f)
                                (#t #f)
                                (else #f))
                              (cond
                                (#\U000541F1 #\U0005C815)
                                (#f #f)
                                (-2 #\醜)
                                (#t #f)
                                (2 #\U00047F8A)
                                (else #t))
                              (cond (#t #\訳) (else #t)))
                          #t)
                         ((cond
                            ((cond (#f #f) (else #t)) (char->integer #f))
                            (#f (if #\U0005878E #t #f))
                            (#t #\U0001E097)
                            ((cond (#t #t) (#f #\쫌) (else #\U000EF517)) (zero? #\儃))
                            (#t
                             (cond
                               (#f #\U000A315A)
                               (#f #f)
                               (#f 4)
                               (#\뙠 1)
                               (#f #\䷼)
                               (#t #t)
                               (2 2)
                               (else #f)))
                            ((if #f #\U0007AAD5 #\U000EBAD5) (if #t #\尊 #f))
                            (10 #f)
                            (-8 (add1 #\恕))
                            ((if #f #\U0002FC5E #t) #f)
                            (#\U000D2D28 (integer->char #f))
                            (#t (cond (else #f)))
                            ((- -1) #\U0009BF72)
                            (#f #\U000EEE90)
                            (else (if 2 #t #f)))
                          #f)
                         ((if #\U000EBDC8 (char? #\U0010DAA4) (cond (else #t)))
                          (integer->char
                           (cond
                             (#\U000A3812 -2)
                             (#t #t)
                             (16 #\簅)
                             (3 #f)
                             (else #t))))
                         ((abs #f) -1)
                         (#\溿 #\U000FC0A9)
                         ((if (if #\U00085911 -3 #f) #\⌐ #t)
                          (integer? (cond (#f #f) (#f #t) (else #f))))
                         (#t (char? (integer->char #t)))
                         ((if (cond (-2 #t) (#f #\U0002CAEA) (else #\踌))
                              #\U00017A3E
                              (cond (#f #f) (1 #\U00048EEA) (else #t)))
                          (cond
                            ((cond (#t #t) (else -5)) -5)
                            ((cond (else #f)) -3)
                            ((if -1 #f #t) #t)
                            ((if 2 #t #\ࢰ) #\䒏)
                            (else (sub1 #f))))
                         (else (integer->char (char->integer #t)))))))
                   (#f #\礧)
                   ((if (add1
                         (cond
                           ((if -4 #t #\沽) 2)
                           ((integer->char 1) 0)
                           (#\䊹
                            (cond
                              (#\ݮ #t)
                              (3 #f)
                              (2 #f)
                              (5 #t)
                              (#f #t)
                              (#\ꉐ #\U0009DB2D)
                              (-4 #t)
                              (#t #f)
                              (else #\깸)))
                           (else 6)))
                        #\흟
                        (if (if #f #\䞀 #t) #f (char->integer #t)))
                    0)
                   (-2 #t)
                   (else #\U000CC456))))
            #f)
          #\U000119C8)
         ((let ((g1 #\蛋)) g1)
          (cond
            (#\␙
             (cond
               (#t
                (cond
                  (#t 0)
                  ((cond (#t #\𩀿) (-4 #t) (#\U00016C85 5) (else #t))
                   (cond
                     (#\U0001E221 #t)
                     (#\辮 #\韄)
                     (#t #\uEA99)
                     (#\u0880 #t)
                     (#t #f)
                     (#f 1)
                     (#\U0005E920 #\㣏)
                     (-2 #\U000DA927)
                     (else #f)))
                  (#f (if 0 #f #t))
                  (#t #\ᙐ)
                  (else (if #t #t #\Ἁ))))
               ((abs #t) #t)
               (else #t)))
            (-1 (cond (else #f)))
            (#f -1)
            (#t #f)
            (else (integer? (add1 (if -1 #t #f))))))
         (-2 (zero? #t))
         (1 (- #\U00049098))
         ((if 1
              (cond
                (#\儓 #t)
                (4 -3)
                (5 #t)
                (-20 #f)
                (#\U00016FB2
                 (if (integer? #t)
                     (cond (else #t))
                     (cond
                       ((cond
                          ((if #t 5 #\뾿) -3)
                          (#t (boolean? #\䭍))
                          (else (cond (#\U00049B6C #t) (else 1))))
                        #\U00094354)
                       (#f (if #t #t #t))
                       (#f (boolean? -2))
                       (#f (integer? (boolean? 5)))
                       ((sub1
                         (cond
                           (-5 #f)
                           (#f #\굹)
                           (#f 3)
                           (#\⪰ #t)
                           (#f #t)
                           (5 #f)
                           (#\⛆ #t)
                           (else -1)))
                        #\刱)
                       (#\ቿ
                        (if (if #t -1 #\U000A28AE) (integer? #\U001037FE) (char? #t)))
                       ((if 8 #f (add1 #f)) #f)
                       (#t #t)
                       ((boolean? (cond (9 -38) (else #f))) #\U0001544B)
                       (#t
                        (cond
                          (#f (if #f #\U00105BF7 0))
                          (#t (if 4 20 #t))
                          (#\U000E5AF4 #\U00042C6B)
                          (else (cond (-2 #\Λ) (#t #t) (#\畬 4) (else #f)))))
                       (#t
                        (cond
                          ((char->integer 2) (cond (else #t)))
                          (-4 (cond (#\든 2) (#t #\U00089BEC) (else #\U00070427)))
                          ((if -1 #\㻍 -5) (cond (else 1)))
                          (else (if #t #\ㆥ -4))))
                       (2 #t)
                       (else #\U000886F3))))
                (#f -1)
                (#\U0007B0F5 -4)
                (#\嗶 #f)
                (else #\U0002E95F))
              #f)
          (let ((o1 #f)) #f))
         ((cond
            ((let ((c2 #t)) #t) (cond (else #t)))
            (#f #f)
            (#f (char->integer #f))
            ((let ((j0 #f)) #f) #t)
            (else #\昫))
          -19)
         (-3 (zero? (cond (else 1))))
         (#t (abs (let ((s0 (sub1 #t))) 3)))
         (else (boolean? (if #f #f #\筲)))))
      (#f
       (cond
         (4 -3)
         ((abs #\U000C77FB) #t)
         (#\U00092FCB (let ((i1 (cond (else #t)))) (if #t #t #\牿)))
         (else -1)))
      ((cond
         ((cond ((if #\ᶛ #t 1) 4) (else (cond (else #f)))) #t)
         (#f (let ((x2 -1)) #t))
         (else #\屹))
       (cond
         ((cond
            ((let ((s0 -1)) #\郿) (if #t #f #\U00037A2F))
            (#t #\⽮)
            (-16 #f)
            (#\餔 2)
            ((cond (else (integer->char (cond (else (if #f #f 5))))))
             (let ((i0 4)) #t))
            (else #f))
          (let ((b0 -2)) (cond (else #f))))
         (1 #f)
         (else #f)))
      ((cond
         (#f (let ((e0 (if #t #t #t))) #t))
         ((if #f #t #t) 16)
         ((cond ((if #t #\覫 #\㗻) #f) (else #t)) #t)
         ((cond
            ((if 5 #\uA7E9 #f)
             (cond
               (-1 #f)
               (#t #\U00071FEF)
               (1 #t)
               (#\羀 2)
               (2 #\赇)
               (#\U000D7979 #f)
               (#\U000F49B2 3)
               (else #\늶)))
            (else -2))
          (cond
            ((char->integer #\𧊲) #t)
            (#f (cond (else #f)))
            ((if (cond
                   ((cond
                      (3 #f)
                      (6 (cond (3 -2) (-11 #t) (#f 0) (#f #t) (else #t)))
                      (#f #f)
                      ((add1 #f) #t)
                      (#\쏊 #f)
                      ((cond (#\鰶 #\펭) (else #t)) (char->integer 5))
                      ((sub1 16) #\䣸)
                      (#t (if #t #\U000B86F7 -1))
                      (#t -1)
                      ((char->integer #t) #\㴡)
                      (else #f))
                    #\螾)
                   (#t #t)
                   (else #\ⓨ))
                 #f
                 -9)
             #f)
            ((cond
               ((cond (else (char? #t))) -5)
               (#f 3)
               (#\鞩 32)
               (#\᳔ 17)
               (#t -3)
               (#f #t)
               (#f #\舕)
               (else #f))
             (cond (else #f)))
            (#f (cond (#f #t) (#t -1) (#\U0010C039 #f) (else #t)))
            (else 8)))
         (#\꒦ -1)
         ((boolean? #f) #f)
         ((let ((o2 (let ((b1 1)) b1))) #\䬂)
          (if (let ((t1 (if 5 (zero? (zero? #t)) (if #f (add1 #f) #\U0007094D))))
                -1)
              -6
              (let ((s0 #\U00097C86)) #f)))
         (4
          (let ((q1
                 (cond
                   ((char?
                     (cond
                       (#f (integer? #f))
                       (#t (if #t #\U00103CAA #\쨒))
                       (#\훧 (add1 #\U00102387))
                       ((cond (else #t))
                        (cond
                          (2 #\添)
                          (#f #f)
                          (#f #f)
                          (-2 #\U000BE1B8)
                          (#t #t)
                          (2 #\U000DA8B6)
                          (else 9)))
                       (#\U00084796
                        (cond
                          (#t #f)
                          (8 #\衵)
                          (#\U00013BCD #t)
                          (#\ࢤ #f)
                          (#f #t)
                          (#f #f)
                          (#f #t)
                          (else 3)))
                       (#f (if #t 3 #f))
                       ((if 3 #\U000EF43C -16) 2)
                       (#f #t)
                       (#\u193D (cond (-3 #t) (#\U0009977F #f) (-4 -1) (else #t)))
                       ((if #\U00061A98 #f -4) (abs #f))
                       ((if #t #f #f) (integer? #f))
                       ((char? #f) -5)
                       (#t (cond (#t #f) (else #\㰖)))
                       (#\瑑 #f)
                       ((zero? -2) #t)
                       (#f (char? #t))
                       (-2 (cond (#t #t) (else #\U000A88B6)))
                       ((cond (#\ṑ #t) (else #t)) (if -4 #\U0008F2DE -1))
                       (else (cond (4 #f) (else #t)))))
                    #f)
                   (#t #t)
                   ((cond
                      ((cond
                         (-2 #\턫)
                         (#f (char? #\uA7B7))
                         (#\U0005041D #f)
                         (#\¹ #\繌)
                         (#\윧 10)
                         (else -3))
                       #t)
                      (#\鷸
                       (boolean?
                        (cond
                          (#t 3)
                          (#\U000A0AE7 #t)
                          (#t #f)
                          (#t -21)
                          (#t #t)
                          (#t #f)
                          (else #f))))
                      (else #f))
                    (cond
                      (32 #t)
                      ((abs #f) (if -3 #\㏟ (char? #f)))
                      ((if (cond (#\뚙 #t) (else #\U000F0326)) #\U0007025B #\늵) -3)
                      (#\uA97D (char? (if -1 #t #f)))
                      (else #f)))
                   (#f -3)
                   ((if (if (cond (else #\ྏ)) (if #f -2 #\ᄚ) (integer? #\鹥))
                        (char? (integer? 2))
                        #t)
                    #\졭)
                   (else
                    (cond
                      ((cond
                         (#f (if 5 -2 #t))
                         ((cond (#f #\U000AE2C1) (#t #\뷁) (else 2)) (integer? -2))
                         ((if #f -2 #f)
                          (cond (#f #f) (#t #f) (#\㊍ #f) (2 -1) (else -16)))
                         ((char? 5) (integer->char #t))
                         ((if 3 #\엾 1) (char->integer #f))
                         (#f -11)
                         ((cond
                            (#f #f)
                            (#t #\뵨)
                            (#\ਟ #\U000E6512)
                            (-2 -1)
                            (#\⾦ #f)
                            (#f #t)
                            (1 -1)
                            (else #\엠))
                          #f)
                         (else #t))
                       (integer->char -2))
                      (#f #f)
                      (else #f))))))
            #t))
         (#t #f)
         (else (cond (-3 -5) ((if #f #t #\U000437D0) (if #f #f -1)) (else #t))))
       (zero? 2))
      (#f (let ((h1 (let ((b0 (cond (#\U0005ADD8 0) (else #t)))) #t))) #t))
      ((cond
         ((sub1 (sub1 (if #\꤇ #f #t)))
          (cond
            (#t #f)
            ((if (char->integer #\U00082C28)
                 (cond
                   (0 #f)
                   (#\ꈧ #f)
                   (#t #t)
                   (#\坃 0)
                   (-5 #f)
                   (#f 0)
                   (2 -1)
                   (#t #f)
                   (else #t))
                 -17)
             (sub1 (integer->char #t)))
            (#f #t)
            ((sub1 (cond (#\䌰 2) (-6 -4) (#f #t) (else #t)))
             (if #\喌 (cond (#f #\簞) (#t #t) (else #t)) -2))
            (else (if (abs #f) #f #\ࠉ))))
         (else (zero? (boolean? #f))))
       #t)
      ((let ((i0
              (zero?
               (let ((d1
                      (if (cond
                            ((cond (#\崈 #\즪) (else (char? #\쳲)))
                             (boolean? (integer? -129)))
                            (else -4))
                          1
                          #f)))
                 #f))))
         (sub1 (let ((l1 i0)) l1)))
       #f)
      (#f -2)
      (#t (let ((c2 -5)) #t))
      (else (integer? -4)))
    (cond (else 3))
    #\U000CF260
    #\㤥
    (let ((v2 #t))
      (if 4
          #t
          (if #t (if #f v2 v2) (cond (#f v2) (#\밡 #\곀) (#f #f) (else -1)))))
    (let ((o1 (if #f #f #f))) (integer->char (boolean? (if -2 #t #f))))
    #f
    #f
    (if -2 #f 3)
    #f
    (let ((s1
           (if (let ((z0 #\౦)) (if -3 #t #f))
               #f
               (let ((w1 #t)) (let ((o0 w1)) w1)))))
      #f)
    -1))