1	# Generated by gen.py from UCD 17.0.0. Do not edit.
2	import Base
3	
4	def gc.n0(lt: Bool, +c: U32) -> String:
5	  match lt:
6	    case True{}:
7	      "Cc"
8	    case False{}:
9	      "Zs"
10	
11	def gc.n1(lt: Bool, +c: U32) -> String:
12	  match lt:
13	    case True{}:
14	      "Po"
15	    case False{}:
16	      "Sc"
17	
18	def gc.n2(lt: Bool, +c: U32) -> String:
19	  match lt:
20	    case True{}:
21	      gc.n0(U32.is_lt(c, 32), c)
22	    case False{}:
23	      gc.n1(U32.is_lt(c, 36), c)
24	
25	def gc.n3(lt: Bool, +c: U32) -> String:
26	  match lt:
27	    case True{}:
28	      "Po"
29	    case False{}:
30	      "Ps"
31	
32	def gc.n4(lt: Bool, +c: U32) -> String:
33	  match lt:
34	    case True{}:
35	      "Pe"
36	    case False{}:
37	      "Po"
38	
39	def gc.n5(lt: Bool, +c: U32) -> String:
40	  match lt:
41	    case True{}:
42	      gc.n3(U32.is_lt(c, 40), c)
43	    case False{}:
44	      gc.n4(U32.is_lt(c, 42), c)
45	
46	def gc.n6(lt: Bool, +c: U32) -> String:
47	  match lt:
48	    case True{}:
49	      gc.n2(U32.is_lt(c, 33), c)
50	    case False{}:
51	      gc.n5(U32.is_lt(c, 41), c)
52	
53	def gc.n7(lt: Bool, +c: U32) -> String:
54	  match lt:
55	    case True{}:
56	      "Sm"
57	    case False{}:
58	      "Po"
59	
60	def gc.n8(lt: Bool, +c: U32) -> String:
61	  match lt:
62	    case True{}:
63	      "Pd"
64	    case False{}:
65	      "Po"
66	
67	def gc.n9(lt: Bool, +c: U32) -> String:
68	  match lt:
69	    case True{}:
70	      gc.n7(U32.is_lt(c, 44), c)
71	    case False{}:
72	      gc.n8(U32.is_lt(c, 46), c)
73	
74	def gc.n10(lt: Bool, +c: U32) -> String:
75	  match lt:
76	    case True{}:
77	      "Nd"
78	    case False{}:
79	      "Po"
80	
81	def gc.n11(lt: Bool, +c: U32) -> String:
82	  match lt:
83	    case True{}:
84	      "Sm"
85	    case False{}:
86	      "Po"
87	
88	def gc.n12(lt: Bool, +c: U32) -> String:
89	  match lt:
90	    case True{}:
91	      gc.n10(U32.is_lt(c, 58), c)
92	    case False{}:
93	      gc.n11(U32.is_lt(c, 63), c)
94	
95	def gc.n13(lt: Bool, +c: U32) -> String:
96	  match lt:
97	    case True{}:
98	      gc.n9(U32.is_lt(c, 45), c)
99	    case False{}:
100	      gc.n12(U32.is_lt(c, 60), c)
101	
102	def gc.n14(lt: Bool, +c: U32) -> String:
103	  match lt:
104	    case True{}:
105	      gc.n6(U32.is_lt(c, 37), c)
106	    case False{}:
107	      gc.n13(U32.is_lt(c, 48), c)
108	
109	def gc.n15(lt: Bool, +c: U32) -> String:
110	  match lt:
111	    case True{}:
112	      "Lu"
113	    case False{}:
114	      "Ps"
115	
116	def gc.n16(lt: Bool, +c: U32) -> String:
117	  match lt:
118	    case True{}:
119	      "Po"
120	    case False{}:
121	      "Pe"
122	
123	def gc.n17(lt: Bool, +c: U32) -> String:
124	  match lt:
125	    case True{}:
126	      gc.n15(U32.is_lt(c, 91), c)
127	    case False{}:
128	      gc.n16(U32.is_lt(c, 93), c)
129	
130	def gc.n18(lt: Bool, +c: U32) -> String:
131	  match lt:
132	    case True{}:
133	      "Sk"
134	    case False{}:
135	      "Pc"
136	
137	def gc.n19(lt: Bool, +c: U32) -> String:
138	  match lt:
139	    case True{}:
140	      "Sk"
141	    case False{}:
142	      "Ll"
143	
144	def gc.n20(lt: Bool, +c: U32) -> String:
145	  match lt:
146	    case True{}:
147	      gc.n18(U32.is_lt(c, 95), c)
148	    case False{}:
149	      gc.n19(U32.is_lt(c, 97), c)
150	
151	def gc.n21(lt: Bool, +c: U32) -> String:
152	  match lt:
153	    case True{}:
154	      gc.n17(U32.is_lt(c, 92), c)
155	    case False{}:
156	      gc.n20(U32.is_lt(c, 96), c)
157	
158	def gc.n22(lt: Bool, +c: U32) -> String:
159	  match lt:
160	    case True{}:
161	      "Ps"
162	    case False{}:
163	      "Sm"
164	
165	def gc.n23(lt: Bool, +c: U32) -> String:
166	  match lt:
167	    case True{}:
168	      "Pe"
169	    case False{}:
170	      "Sm"
171	
172	def gc.n24(lt: Bool, +c: U32) -> String:
173	  match lt:
174	    case True{}:
175	      gc.n22(U32.is_lt(c, 124), c)
176	    case False{}:
177	      gc.n23(U32.is_lt(c, 126), c)
178	
179	def gc.n25(lt: Bool, +c: U32) -> String:
180	  match lt:
181	    case True{}:
182	      "Cc"
183	    case False{}:
184	      "Zs"
185	
186	def gc.n26(lt: Bool, +c: U32) -> String:
187	  match lt:
188	    case True{}:
189	      "Po"
190	    case False{}:
191	      "Sc"
192	
193	def gc.n27(lt: Bool, +c: U32) -> String:
194	  match lt:
195	    case True{}:
196	      gc.n25(U32.is_lt(c, 160), c)
197	    case False{}:
198	      gc.n26(U32.is_lt(c, 162), c)
199	
200	def gc.n28(lt: Bool, +c: U32) -> String:
201	  match lt:
202	    case True{}:
203	      gc.n24(U32.is_lt(c, 125), c)
204	    case False{}:
205	      gc.n27(U32.is_lt(c, 161), c)
206	
207	def gc.n29(lt: Bool, +c: U32) -> String:
208	  match lt:
209	    case True{}:
210	      gc.n21(U32.is_lt(c, 94), c)
211	    case False{}:
212	      gc.n28(U32.is_lt(c, 127), c)
213	
214	def gc.n30(lt: Bool, +c: U32) -> String:
215	  match lt:
216	    case True{}:
217	      gc.n14(U32.is_lt(c, 43), c)
218	    case False{}:
219	      gc.n29(U32.is_lt(c, 123), c)
220	
221	def gc.n31(lt: Bool, +c: U32) -> String:
222	  match lt:
223	    case True{}:
224	      "So"
225	    case False{}:
226	      "Po"
227	
228	def gc.n32(lt: Bool, +c: U32) -> String:
229	  match lt:
230	    case True{}:
231	      "Sk"
232	    case False{}:
233	      "So"
234	
235	def gc.n33(lt: Bool, +c: U32) -> String:
236	  match lt:
237	    case True{}:
238	      gc.n31(U32.is_lt(c, 167), c)
239	    case False{}:
240	      gc.n32(U32.is_lt(c, 169), c)
241	
242	def gc.n34(lt: Bool, +c: U32) -> String:
243	  match lt:
244	    case True{}:
245	      "Lo"
246	    case False{}:
247	      "Pi"
248	
249	def gc.n35(lt: Bool, +c: U32) -> String:
250	  match lt:
251	    case True{}:
252	      "Sm"
253	    case False{}:
254	      "Cf"
255	
256	def gc.n36(lt: Bool, +c: U32) -> String:
257	  match lt:
258	    case True{}:
259	      gc.n34(U32.is_lt(c, 171), c)
260	    case False{}:
261	      gc.n35(U32.is_lt(c, 173), c)
262	
263	def gc.n37(lt: Bool, +c: U32) -> String:
264	  match lt:
265	    case True{}:
266	      gc.n33(U32.is_lt(c, 168), c)
267	    case False{}:
268	      gc.n36(U32.is_lt(c, 172), c)
269	
270	def gc.n38(lt: Bool, +c: U32) -> String:
271	  match lt:
272	    case True{}:
273	      "So"
274	    case False{}:
275	      "Sk"
276	
277	def gc.n39(lt: Bool, +c: U32) -> String:
278	  match lt:
279	    case True{}:
280	      "So"
281	    case False{}:
282	      "Sm"
283	
284	def gc.n40(lt: Bool, +c: U32) -> String:
285	  match lt:
286	    case True{}:
287	      gc.n38(U32.is_lt(c, 175), c)
288	    case False{}:
289	      gc.n39(U32.is_lt(c, 177), c)
290	
291	def gc.n41(lt: Bool, +c: U32) -> String:
292	  match lt:
293	    case True{}:
294	      "No"
295	    case False{}:
296	      "Sk"
297	
298	def gc.n42(lt: Bool, +c: U32) -> String:
299	  match lt:
300	    case True{}:
301	      "Ll"
302	    case False{}:
303	      "Po"
304	
305	def gc.n43(lt: Bool, +c: U32) -> String:
306	  match lt:
307	    case True{}:
308	      gc.n41(U32.is_lt(c, 180), c)
309	    case False{}:
310	      gc.n42(U32.is_lt(c, 182), c)
311	
312	def gc.n44(lt: Bool, +c: U32) -> String:
313	  match lt:
314	    case True{}:
315	      gc.n40(U32.is_lt(c, 176), c)
316	    case False{}:
317	      gc.n43(U32.is_lt(c, 181), c)
318	
319	def gc.n45(lt: Bool, +c: U32) -> String:
320	  match lt:
321	    case True{}:
322	      gc.n37(U32.is_lt(c, 170), c)
323	    case False{}:
324	      gc.n44(U32.is_lt(c, 178), c)
325	
326	def gc.n46(lt: Bool, +c: U32) -> String:
327	  match lt:
328	    case True{}:
329	      "Sk"
330	    case False{}:
331	      "No"
332	
333	def gc.n47(lt: Bool, +c: U32) -> String:
334	  match lt:
335	    case True{}:
336	      "Lo"
337	    case False{}:
338	      "Pf"
339	
340	def gc.n48(lt: Bool, +c: U32) -> String:
341	  match lt:
342	    case True{}:
343	      gc.n46(U32.is_lt(c, 185), c)
344	    case False{}:
345	      gc.n47(U32.is_lt(c, 187), c)
346	
347	def gc.n49(lt: Bool, +c: U32) -> String:
348	  match lt:
349	    case True{}:
350	      "No"
351	    case False{}:
352	      "Po"
353	
354	def gc.n50(lt: Bool, +c: U32) -> String:
355	  match lt:
356	    case True{}:
357	      "Lu"
358	    case False{}:
359	      "Sm"
360	
361	def gc.n51(lt: Bool, +c: U32) -> String:
362	  match lt:
363	    case True{}:
364	      gc.n49(U32.is_lt(c, 191), c)
365	    case False{}:
366	      gc.n50(U32.is_lt(c, 215), c)
367	
368	def gc.n52(lt: Bool, +c: U32) -> String:
369	  match lt:
370	    case True{}:
371	      gc.n48(U32.is_lt(c, 186), c)
372	    case False{}:
373	      gc.n51(U32.is_lt(c, 192), c)
374	
375	def gc.n53(lt: Bool, +c: U32) -> String:
376	  match lt:
377	    case True{}:
378	      "Lu"
379	    case False{}:
380	      "Ll"
381	
382	def gc.n54(lt: Bool, +c: U32) -> String:
383	  match lt:
384	    case True{}:
385	      "Sm"
386	    case False{}:
387	      "Ll"
388	
389	def gc.n55(lt: Bool, +c: U32) -> String:
390	  match lt:
391	    case True{}:
392	      gc.n53(U32.is_lt(c, 223), c)
393	    case False{}:
394	      gc.n54(U32.is_lt(c, 248), c)
395	
396	def gc.n56(lt: Bool, +c: U32) -> String:
397	  match lt:
398	    case True{}:
399	      "Lu"
400	    case False{}:
401	      "Ll"
402	
403	def gc.n57(lt: Bool, +c: U32) -> String:
404	  match lt:
405	    case True{}:
406	      "Lu"
407	    case False{}:
408	      "Ll"
409	
410	def gc.n58(lt: Bool, +c: U32) -> String:
411	  match lt:
412	    case True{}:
413	      gc.n56(U32.is_lt(c, 257), c)
414	    case False{}:
415	      gc.n57(U32.is_lt(c, 259), c)
416	
417	def gc.n59(lt: Bool, +c: U32) -> String:
418	  match lt:
419	    case True{}:
420	      gc.n55(U32.is_lt(c, 247), c)
421	    case False{}:
422	      gc.n58(U32.is_lt(c, 258), c)
423	
424	def gc.n60(lt: Bool, +c: U32) -> String:
425	  match lt:
426	    case True{}:
427	      gc.n52(U32.is_lt(c, 188), c)
428	    case False{}:
429	      gc.n59(U32.is_lt(c, 256), c)
430	
431	def gc.n61(lt: Bool, +c: U32) -> String:
432	  match lt:
433	    case True{}:
434	      gc.n45(U32.is_lt(c, 174), c)
435	    case False{}:
436	      gc.n60(U32.is_lt(c, 216), c)
437	
438	def gc.n62(lt: Bool, +c: U32) -> String:
439	  match lt:
440	    case True{}:
441	      gc.n30(U32.is_lt(c, 65), c)
442	    case False{}:
443	      gc.n61(U32.is_lt(c, 184), c)
444	
445	def gc.n63(lt: Bool, +c: U32) -> String:
446	  match lt:
447	    case True{}:
448	      "Lu"
449	    case False{}:
450	      "Ll"
451	
452	def gc.n64(lt: Bool, +c: U32) -> String:
453	  match lt:
454	    case True{}:
455	      "Lu"
456	    case False{}:
457	      "Ll"
458	
459	def gc.n65(lt: Bool, +c: U32) -> String:
460	  match lt:
461	    case True{}:
462	      gc.n63(U32.is_lt(c, 261), c)
463	    case False{}:
464	      gc.n64(U32.is_lt(c, 263), c)
465	
466	def gc.n66(lt: Bool, +c: U32) -> String:
467	  match lt:
468	    case True{}:
469	      "Lu"
470	    case False{}:
471	      "Ll"
472	
473	def gc.n67(lt: Bool, +c: U32) -> String:
474	  match lt:
475	    case True{}:
476	      "Lu"
477	    case False{}:
478	      "Ll"
479	
480	def gc.n68(lt: Bool, +c: U32) -> String:
481	  match lt:
482	    case True{}:
483	      gc.n66(U32.is_lt(c, 265), c)
484	    case False{}:
485	      gc.n67(U32.is_lt(c, 267), c)
486	
487	def gc.n69(lt: Bool, +c: U32) -> String:
488	  match lt:
489	    case True{}:
490	      gc.n65(U32.is_lt(c, 262), c)
491	    case False{}:
492	      gc.n68(U32.is_lt(c, 266), c)
493	
494	def gc.n70(lt: Bool, +c: U32) -> String:
495	  match lt:
496	    case True{}:
497	      "Lu"
498	    case False{}:
499	      "Ll"
500	
501	def gc.n71(lt: Bool, +c: U32) -> String:
502	  match lt:
503	    case True{}:
504	      "Lu"
505	    case False{}:
506	      "Ll"
507	
508	def gc.n72(lt: Bool, +c: U32) -> String:
509	  match lt:
510	    case True{}:
511	      gc.n70(U32.is_lt(c, 269), c)
512	    case False{}:
513	      gc.n71(U32.is_lt(c, 271), c)
514	
515	def gc.n73(lt: Bool, +c: U32) -> String:
516	  match lt:
517	    case True{}:
518	      "Lu"
519	    case False{}:
520	      "Ll"
521	
522	def gc.n74(lt: Bool, +c: U32) -> String:
523	  match lt:
524	    case True{}:
525	      "Lu"
526	    case False{}:
527	      "Ll"
528	
529	def gc.n75(lt: Bool, +c: U32) -> String:
530	  match lt:
531	    case True{}:
532	      gc.n73(U32.is_lt(c, 273), c)
533	    case False{}:
534	      gc.n74(U32.is_lt(c, 275), c)
535	
536	def gc.n76(lt: Bool, +c: U32) -> String:
537	  match lt:
538	    case True{}:
539	      gc.n72(U32.is_lt(c, 270), c)
540	    case False{}:
541	      gc.n75(U32.is_lt(c, 274), c)
542	
543	def gc.n77(lt: Bool, +c: U32) -> String:
544	  match lt:
545	    case True{}:
546	      gc.n69(U32.is_lt(c, 264), c)
547	    case False{}:
548	      gc.n76(U32.is_lt(c, 272), c)
549	
550	def gc.n78(lt: Bool, +c: U32) -> String:
551	  match lt:
552	    case True{}:
553	      "Lu"
554	    case False{}:
555	      "Ll"
556	
557	def gc.n79(lt: Bool, +c: U32) -> String:
558	  match lt:
559	    case True{}:
560	      "Lu"
561	    case False{}:
562	      "Ll"
563	
564	def gc.n80(lt: Bool, +c: U32) -> String:
565	  match lt:
566	    case True{}:
567	      gc.n78(U32.is_lt(c, 277), c)
568	    case False{}:
569	      gc.n79(U32.is_lt(c, 279), c)
570	
571	def gc.n81(lt: Bool, +c: U32) -> String:
572	  match lt:
573	    case True{}:
574	      "Lu"
575	    case False{}:
576	      "Ll"
577	
578	def gc.n82(lt: Bool, +c: U32) -> String:
579	  match lt:
580	    case True{}:
581	      "Lu"
582	    case False{}:
583	      "Ll"
584	
585	def gc.n83(lt: Bool, +c: U32) -> String:
586	  match lt:
587	    case True{}:
588	      gc.n81(U32.is_lt(c, 281), c)
589	    case False{}:
590	      gc.n82(U32.is_lt(c, 283), c)
591	
592	def gc.n84(lt: Bool, +c: U32) -> String:
593	  match lt:
594	    case True{}:
595	      gc.n80(U32.is_lt(c, 278), c)
596	    case False{}:
597	      gc.n83(U32.is_lt(c, 282), c)
598	
599	def gc.n85(lt: Bool, +c: U32) -> String:
600	  match lt:
601	    case True{}:
602	      "Lu"
603	    case False{}:
604	      "Ll"
605	
606	def gc.n86(lt: Bool, +c: U32) -> String:
607	  match lt:
608	    case True{}:
609	      "Lu"
610	    case False{}:
611	      "Ll"
612	
613	def gc.n87(lt: Bool, +c: U32) -> String:
614	  match lt:
615	    case True{}:
616	      gc.n85(U32.is_lt(c, 285), c)
617	    case False{}:
618	      gc.n86(U32.is_lt(c, 287), c)
619	
620	def gc.n88(lt: Bool, +c: U32) -> String:
621	  match lt:
622	    case True{}:
623	      "Lu"
624	    case False{}:
625	      "Ll"
626	
627	def gc.n89(lt: Bool, +c: U32) -> String:
628	  match lt:
629	    case True{}:
630	      "Lu"
631	    case False{}:
632	      "Ll"
633	
634	def gc.n90(lt: Bool, +c: U32) -> String:
635	  match lt:
636	    case True{}:
637	      gc.n88(U32.is_lt(c, 289), c)
638	    case False{}:
639	      gc.n89(U32.is_lt(c, 291), c)
640	
641	def gc.n91(lt: Bool, +c: U32) -> String:
642	  match lt:
643	    case True{}:
644	      gc.n87(U32.is_lt(c, 286), c)
645	    case False{}:
646	      gc.n90(U32.is_lt(c, 290), c)
647	
648	def gc.n92(lt: Bool, +c: U32) -> String:
649	  match lt:
650	    case True{}:
651	      gc.n84(U32.is_lt(c, 280), c)
652	    case False{}:
653	      gc.n91(U32.is_lt(c, 288), c)
654	
655	def gc.n93(lt: Bool, +c: U32) -> String:
656	  match lt:
657	    case True{}:
658	      gc.n77(U32.is_lt(c, 268), c)
659	    case False{}:
660	      gc.n92(U32.is_lt(c, 284), c)
661	
662	def gc.n94(lt: Bool, +c: U32) -> String:
663	  match lt:
664	    case True{}:
665	      "Lu"
666	    case False{}:
667	      "Ll"
668	
669	def gc.n95(lt: Bool, +c: U32) -> String:
670	  match lt:
671	    case True{}:
672	      "Lu"
673	    case False{}:
674	      "Ll"
675	
676	def gc.n96(lt: Bool, +c: U32) -> String:
677	  match lt:
678	    case True{}:
679	      gc.n94(U32.is_lt(c, 293), c)
680	    case False{}:
681	      gc.n95(U32.is_lt(c, 295), c)
682	
683	def gc.n97(lt: Bool, +c: U32) -> String:
684	  match lt:
685	    case True{}:
686	      "Lu"
687	    case False{}:
688	      "Ll"
689	
690	def gc.n98(lt: Bool, +c: U32) -> String:
691	  match lt:
692	    case True{}:
693	      "Lu"
694	    case False{}:
695	      "Ll"
696	
697	def gc.n99(lt: Bool, +c: U32) -> String:
698	  match lt:
699	    case True{}:
700	      gc.n97(U32.is_lt(c, 297), c)
701	    case False{}:
702	      gc.n98(U32.is_lt(c, 299), c)
703	
704	def gc.n100(lt: Bool, +c: U32) -> String:
705	  match lt:
706	    case True{}:
707	      gc.n96(U32.is_lt(c, 294), c)
708	    case False{}:
709	      gc.n99(U32.is_lt(c, 298), c)
710	
711	def gc.n101(lt: Bool, +c: U32) -> String:
712	  match lt:
713	    case True{}:
714	      "Lu"
715	    case False{}:
716	      "Ll"
717	
718	def gc.n102(lt: Bool, +c: U32) -> String:
719	  match lt:
720	    case True{}:
721	      "Lu"
722	    case False{}:
723	      "Ll"
724	
725	def gc.n103(lt: Bool, +c: U32) -> String:
726	  match lt:
727	    case True{}:
728	      gc.n101(U32.is_lt(c, 301), c)
729	    case False{}:
730	      gc.n102(U32.is_lt(c, 303), c)
731	
732	def gc.n104(lt: Bool, +c: U32) -> String:
733	  match lt:
734	    case True{}:
735	      "Lu"
736	    case False{}:
737	      "Ll"
738	
739	def gc.n105(lt: Bool, +c: U32) -> String:
740	  match lt:
741	    case True{}:
742	      "Lu"
743	    case False{}:
744	      "Ll"
745	
746	def gc.n106(lt: Bool, +c: U32) -> String:
747	  match lt:
748	    case True{}:
749	      gc.n104(U32.is_lt(c, 305), c)
750	    case False{}:
751	      gc.n105(U32.is_lt(c, 307), c)
752	
753	def gc.n107(lt: Bool, +c: U32) -> String:
754	  match lt:
755	    case True{}:
756	      gc.n103(U32.is_lt(c, 302), c)
757	    case False{}:
758	      gc.n106(U32.is_lt(c, 306), c)
759	
760	def gc.n108(lt: Bool, +c: U32) -> String:
761	  match lt:
762	    case True{}:
763	      gc.n100(U32.is_lt(c, 296), c)
764	    case False{}:
765	      gc.n107(U32.is_lt(c, 304), c)
766	
767	def gc.n109(lt: Bool, +c: U32) -> String:
768	  match lt:
769	    case True{}:
770	      "Lu"
771	    case False{}:
772	      "Ll"
773	
774	def gc.n110(lt: Bool, +c: U32) -> String:
775	  match lt:
776	    case True{}:
777	      "Lu"
778	    case False{}:
779	      "Ll"
780	
781	def gc.n111(lt: Bool, +c: U32) -> String:
782	  match lt:
783	    case True{}:
784	      gc.n109(U32.is_lt(c, 309), c)
785	    case False{}:
786	      gc.n110(U32.is_lt(c, 311), c)
787	
788	def gc.n112(lt: Bool, +c: U32) -> String:
789	  match lt:
790	    case True{}:
791	      "Lu"
792	    case False{}:
793	      "Ll"
794	
795	def gc.n113(lt: Bool, +c: U32) -> String:
796	  match lt:
797	    case True{}:
798	      "Lu"
799	    case False{}:
800	      "Ll"
801	
802	def gc.n114(lt: Bool, +c: U32) -> String:
803	  match lt:
804	    case True{}:
805	      gc.n112(U32.is_lt(c, 314), c)
806	    case False{}:
807	      gc.n113(U32.is_lt(c, 316), c)
808	
809	def gc.n115(lt: Bool, +c: U32) -> String:
810	  match lt:
811	    case True{}:
812	      gc.n111(U32.is_lt(c, 310), c)
813	    case False{}:
814	      gc.n114(U32.is_lt(c, 315), c)
815	
816	def gc.n116(lt: Bool, +c: U32) -> String:
817	  match lt:
818	    case True{}:
819	      "Lu"
820	    case False{}:
821	      "Ll"
822	
823	def gc.n117(lt: Bool, +c: U32) -> String:
824	  match lt:
825	    case True{}:
826	      "Lu"
827	    case False{}:
828	      "Ll"
829	
830	def gc.n118(lt: Bool, +c: U32) -> String:
831	  match lt:
832	    case True{}:
833	      gc.n116(U32.is_lt(c, 318), c)
834	    case False{}:
835	      gc.n117(U32.is_lt(c, 320), c)
836	
837	def gc.n119(lt: Bool, +c: U32) -> String:
838	  match lt:
839	    case True{}:
840	      "Lu"
841	    case False{}:
842	      "Ll"
843	
844	def gc.n120(lt: Bool, +c: U32) -> String:
845	  match lt:
846	    case True{}:
847	      "Ll"
848	    case False{}:
849	      "Lu"
850	
851	def gc.n121(lt: Bool, +c: U32) -> String:
852	  match lt:
853	    case True{}:
854	      "Lu"
855	    case False{}:
856	      gc.n120(U32.is_lt(c, 325), c)
857	
858	def gc.n122(lt: Bool, +c: U32) -> String:
859	  match lt:
860	    case True{}:
861	      gc.n119(U32.is_lt(c, 322), c)
862	    case False{}:
863	      gc.n121(U32.is_lt(c, 324), c)
864	
865	def gc.n123(lt: Bool, +c: U32) -> String:
866	  match lt:
867	    case True{}:
868	      gc.n118(U32.is_lt(c, 319), c)
869	    case False{}:
870	      gc.n122(U32.is_lt(c, 323), c)
871	
872	def gc.n124(lt: Bool, +c: U32) -> String:
873	  match lt:
874	    case True{}:
875	      gc.n115(U32.is_lt(c, 313), c)
876	    case False{}:
877	      gc.n123(U32.is_lt(c, 321), c)
878	
879	def gc.n125(lt: Bool, +c: U32) -> String:
880	  match lt:
881	    case True{}:
882	      gc.n108(U32.is_lt(c, 300), c)
883	    case False{}:
884	      gc.n124(U32.is_lt(c, 317), c)
885	
886	def gc.n126(lt: Bool, +c: U32) -> String:
887	  match lt:
888	    case True{}:
889	      gc.n93(U32.is_lt(c, 276), c)
890	    case False{}:
891	      gc.n125(U32.is_lt(c, 308), c)
892	
893	def gc.n127(lt: Bool, +c: U32) -> String:
894	  match lt:
895	    case True{}:
896	      gc.n62(U32.is_lt(c, 166), c)
897	    case False{}:
898	      gc.n126(U32.is_lt(c, 292), c)
899	
900	def gc.n128(lt: Bool, +c: U32) -> String:
901	  match lt:
902	    case True{}:
903	      "Ll"
904	    case False{}:
905	      "Lu"
906	
907	def gc.n129(lt: Bool, +c: U32) -> String:
908	  match lt:
909	    case True{}:
910	      "Ll"
911	    case False{}:
912	      "Lu"
913	
914	def gc.n130(lt: Bool, +c: U32) -> String:
915	  match lt:
916	    case True{}:
917	      gc.n128(U32.is_lt(c, 327), c)
918	    case False{}:
919	      gc.n129(U32.is_lt(c, 330), c)
920	
921	def gc.n131(lt: Bool, +c: U32) -> String:
922	  match lt:
923	    case True{}:
924	      "Ll"
925	    case False{}:
926	      "Lu"
927	
928	def gc.n132(lt: Bool, +c: U32) -> String:
929	  match lt:
930	    case True{}:
931	      "Ll"
932	    case False{}:
933	      "Lu"
934	
935	def gc.n133(lt: Bool, +c: U32) -> String:
936	  match lt:
937	    case True{}:
938	      gc.n131(U32.is_lt(c, 332), c)
939	    case False{}:
940	      gc.n132(U32.is_lt(c, 334), c)
941	
942	def gc.n134(lt: Bool, +c: U32) -> String:
943	  match lt:
944	    case True{}:
945	      gc.n130(U32.is_lt(c, 328), c)
946	    case False{}:
947	      gc.n133(U32.is_lt(c, 333), c)
948	
949	def gc.n135(lt: Bool, +c: U32) -> String:
950	  match lt:
951	    case True{}:
952	      "Ll"
953	    case False{}:
954	      "Lu"
955	
956	def gc.n136(lt: Bool, +c: U32) -> String:
957	  match lt:
958	    case True{}:
959	      "Ll"
960	    case False{}:
961	      "Lu"
962	
963	def gc.n137(lt: Bool, +c: U32) -> String:
964	  match lt:
965	    case True{}:
966	      gc.n135(U32.is_lt(c, 336), c)
967	    case False{}:
968	      gc.n136(U32.is_lt(c, 338), c)
969	
970	def gc.n138(lt: Bool, +c: U32) -> String:
971	  match lt:
972	    case True{}:
973	      "Ll"
974	    case False{}:
975	      "Lu"
976	
977	def gc.n139(lt: Bool, +c: U32) -> String:
978	  match lt:
979	    case True{}:
980	      "Ll"
981	    case False{}:
982	      "Lu"
983	
984	def gc.n140(lt: Bool, +c: U32) -> String:
985	  match lt:
986	    case True{}:
987	      gc.n138(U32.is_lt(c, 340), c)
988	    case False{}:
989	      gc.n139(U32.is_lt(c, 342), c)
990	
991	def gc.n141(lt: Bool, +c: U32) -> String:
992	  match lt:
993	    case True{}:
994	      gc.n137(U32.is_lt(c, 337), c)
995	    case False{}:
996	      gc.n140(U32.is_lt(c, 341), c)
997	
998	def gc.n142(lt: Bool, +c: U32) -> String:
999	  match lt:
1000	    case True{}:
1001	      gc.n134(U32.is_lt(c, 331), c)
1002	    case False{}:
1003	      gc.n141(U32.is_lt(c, 339), c)
1004	
1005	def gc.n143(lt: Bool, +c: U32) -> String:
1006	  match lt:
1007	    case True{}:
1008	      "Ll"
1009	    case False{}:
1010	      "Lu"
1011	
1012	def gc.n144(lt: Bool, +c: U32) -> String:
1013	  match lt:
1014	    case True{}:
1015	      "Ll"
1016	    case False{}:
1017	      "Lu"
1018	
1019	def gc.n145(lt: Bool, +c: U32) -> String:
1020	  match lt:
1021	    case True{}:
1022	      gc.n143(U32.is_lt(c, 344), c)
1023	    case False{}:
1024	      gc.n144(U32.is_lt(c, 346), c)
1025	
1026	def gc.n146(lt: Bool, +c: U32) -> String:
1027	  match lt:
1028	    case True{}:
1029	      "Ll"
1030	    case False{}:
1031	      "Lu"
1032	
1033	def gc.n147(lt: Bool, +c: U32) -> String:
1034	  match lt:
1035	    case True{}:
1036	      "Ll"
1037	    case False{}:
1038	      "Lu"
1039	
1040	def gc.n148(lt: Bool, +c: U32) -> String:
1041	  match lt:
1042	    case True{}:
1043	      gc.n146(U32.is_lt(c, 348), c)
1044	    case False{}:
1045	      gc.n147(U32.is_lt(c, 350), c)
1046	
1047	def gc.n149(lt: Bool, +c: U32) -> String:
1048	  match lt:
1049	    case True{}:
1050	      gc.n145(U32.is_lt(c, 345), c)
1051	    case False{}:
1052	      gc.n148(U32.is_lt(c, 349), c)
1053	
1054	def gc.n150(lt: Bool, +c: U32) -> String:
1055	  match lt:
1056	    case True{}:
1057	      "Ll"
1058	    case False{}:
1059	      "Lu"
1060	
1061	def gc.n151(lt: Bool, +c: U32) -> String:
1062	  match lt:
1063	    case True{}:
1064	      "Ll"
1065	    case False{}:
1066	      "Lu"
1067	
1068	def gc.n152(lt: Bool, +c: U32) -> String:
1069	  match lt:
1070	    case True{}:
1071	      gc.n150(U32.is_lt(c, 352), c)
1072	    case False{}:
1073	      gc.n151(U32.is_lt(c, 354), c)
1074	
1075	def gc.n153(lt: Bool, +c: U32) -> String:
1076	  match lt:
1077	    case True{}:
1078	      "Ll"
1079	    case False{}:
1080	      "Lu"
1081	
1082	def gc.n154(lt: Bool, +c: U32) -> String:
1083	  match lt:
1084	    case True{}:
1085	      "Ll"
1086	    case False{}:
1087	      "Lu"
1088	
1089	def gc.n155(lt: Bool, +c: U32) -> String:
1090	  match lt:
1091	    case True{}:
1092	      gc.n153(U32.is_lt(c, 356), c)
1093	    case False{}:
1094	      gc.n154(U32.is_lt(c, 358), c)
1095	
1096	def gc.n156(lt: Bool, +c: U32) -> String:
1097	  match lt:
1098	    case True{}:
1099	      gc.n152(U32.is_lt(c, 353), c)
1100	    case False{}:
1101	      gc.n155(U32.is_lt(c, 357), c)
1102	
1103	def gc.n157(lt: Bool, +c: U32) -> String:
1104	  match lt:
1105	    case True{}:
1106	      gc.n149(U32.is_lt(c, 347), c)
1107	    case False{}:
1108	      gc.n156(U32.is_lt(c, 355), c)
1109	
1110	def gc.n158(lt: Bool, +c: U32) -> String:
1111	  match lt:
1112	    case True{}:
1113	      gc.n142(U32.is_lt(c, 335), c)
1114	    case False{}:
1115	      gc.n157(U32.is_lt(c, 351), c)
1116	
1117	def gc.n159(lt: Bool, +c: U32) -> String:
1118	  match lt:
1119	    case True{}:
1120	      "Ll"
1121	    case False{}:
1122	      "Lu"
1123	
1124	def gc.n160(lt: Bool, +c: U32) -> String:
1125	  match lt:
1126	    case True{}:
1127	      "Ll"
1128	    case False{}:
1129	      "Lu"
1130	
1131	def gc.n161(lt: Bool, +c: U32) -> String:
1132	  match lt:
1133	    case True{}:
1134	      gc.n159(U32.is_lt(c, 360), c)
1135	    case False{}:
1136	      gc.n160(U32.is_lt(c, 362), c)
1137	
1138	def gc.n162(lt: Bool, +c: U32) -> String:
1139	  match lt:
1140	    case True{}:
1141	      "Ll"
1142	    case False{}:
1143	      "Lu"
1144	
1145	def gc.n163(lt: Bool, +c: U32) -> String:
1146	  match lt:
1147	    case True{}:
1148	      "Ll"
1149	    case False{}:
1150	      "Lu"
1151	
1152	def gc.n164(lt: Bool, +c: U32) -> String:
1153	  match lt:
1154	    case True{}:
1155	      gc.n162(U32.is_lt(c, 364), c)
1156	    case False{}:
1157	      gc.n163(U32.is_lt(c, 366), c)
1158	
1159	def gc.n165(lt: Bool, +c: U32) -> String:
1160	  match lt:
1161	    case True{}:
1162	      gc.n161(U32.is_lt(c, 361), c)
1163	    case False{}:
1164	      gc.n164(U32.is_lt(c, 365), c)
1165	
1166	def gc.n166(lt: Bool, +c: U32) -> String:
1167	  match lt:
1168	    case True{}:
1169	      "Ll"
1170	    case False{}:
1171	      "Lu"
1172	
1173	def gc.n167(lt: Bool, +c: U32) -> String:
1174	  match lt:
1175	    case True{}:
1176	      "Ll"
1177	    case False{}:
1178	      "Lu"
1179	
1180	def gc.n168(lt: Bool, +c: U32) -> String:
1181	  match lt:
1182	    case True{}:
1183	      gc.n166(U32.is_lt(c, 368), c)
1184	    case False{}:
1185	      gc.n167(U32.is_lt(c, 370), c)
1186	
1187	def gc.n169(lt: Bool, +c: U32) -> String:
1188	  match lt:
1189	    case True{}:
1190	      "Ll"
1191	    case False{}:
1192	      "Lu"
1193	
1194	def gc.n170(lt: Bool, +c: U32) -> String:
1195	  match lt:
1196	    case True{}:
1197	      "Ll"
1198	    case False{}:
1199	      "Lu"
1200	
1201	def gc.n171(lt: Bool, +c: U32) -> String:
1202	  match lt:
1203	    case True{}:
1204	      gc.n169(U32.is_lt(c, 372), c)
1205	    case False{}:
1206	      gc.n170(U32.is_lt(c, 374), c)
1207	
1208	def gc.n172(lt: Bool, +c: U32) -> String:
1209	  match lt:
1210	    case True{}:
1211	      gc.n168(U32.is_lt(c, 369), c)
1212	    case False{}:
1213	      gc.n171(U32.is_lt(c, 373), c)
1214	
1215	def gc.n173(lt: Bool, +c: U32) -> String:
1216	  match lt:
1217	    case True{}:
1218	      gc.n165(U32.is_lt(c, 363), c)
1219	    case False{}:
1220	      gc.n172(U32.is_lt(c, 371), c)
1221	
1222	def gc.n174(lt: Bool, +c: U32) -> String:
1223	  match lt:
1224	    case True{}:
1225	      "Ll"
1226	    case False{}:
1227	      "Lu"
1228	
1229	def gc.n175(lt: Bool, +c: U32) -> String:
1230	  match lt:
1231	    case True{}:
1232	      "Ll"
1233	    case False{}:
1234	      "Lu"
1235	
1236	def gc.n176(lt: Bool, +c: U32) -> String:
1237	  match lt:
1238	    case True{}:
1239	      gc.n174(U32.is_lt(c, 376), c)
1240	    case False{}:
1241	      gc.n175(U32.is_lt(c, 379), c)
1242	
1243	def gc.n177(lt: Bool, +c: U32) -> String:
1244	  match lt:
1245	    case True{}:
1246	      "Ll"
1247	    case False{}:
1248	      "Lu"
1249	
1250	def gc.n178(lt: Bool, +c: U32) -> String:
1251	  match lt:
1252	    case True{}:
1253	      "Ll"
1254	    case False{}:
1255	      "Lu"
1256	
1257	def gc.n179(lt: Bool, +c: U32) -> String:
1258	  match lt:
1259	    case True{}:
1260	      gc.n177(U32.is_lt(c, 381), c)
1261	    case False{}:
1262	      gc.n178(U32.is_lt(c, 385), c)
1263	
1264	def gc.n180(lt: Bool, +c: U32) -> String:
1265	  match lt:
1266	    case True{}:
1267	      gc.n176(U32.is_lt(c, 378), c)
1268	    case False{}:
1269	      gc.n179(U32.is_lt(c, 382), c)
1270	
1271	def gc.n181(lt: Bool, +c: U32) -> String:
1272	  match lt:
1273	    case True{}:
1274	      "Ll"
1275	    case False{}:
1276	      "Lu"
1277	
1278	def gc.n182(lt: Bool, +c: U32) -> String:
1279	  match lt:
1280	    case True{}:
1281	      "Ll"
1282	    case False{}:
1283	      "Lu"
1284	
1285	def gc.n183(lt: Bool, +c: U32) -> String:
1286	  match lt:
1287	    case True{}:
1288	      gc.n181(U32.is_lt(c, 388), c)
1289	    case False{}:
1290	      gc.n182(U32.is_lt(c, 390), c)
1291	
1292	def gc.n184(lt: Bool, +c: U32) -> String:
1293	  match lt:
1294	    case True{}:
1295	      "Ll"
1296	    case False{}:
1297	      "Lu"
1298	
1299	def gc.n185(lt: Bool, +c: U32) -> String:
1300	  match lt:
1301	    case True{}:
1302	      "Lu"
1303	    case False{}:
1304	      "Ll"
1305	
1306	def gc.n186(lt: Bool, +c: U32) -> String:
1307	  match lt:
1308	    case True{}:
1309	      "Ll"
1310	    case False{}:
1311	      gc.n185(U32.is_lt(c, 402), c)
1312	
1313	def gc.n187(lt: Bool, +c: U32) -> String:
1314	  match lt:
1315	    case True{}:
1316	      gc.n184(U32.is_lt(c, 393), c)
1317	    case False{}:
1318	      gc.n186(U32.is_lt(c, 398), c)
1319	
1320	def gc.n188(lt: Bool, +c: U32) -> String:
1321	  match lt:
1322	    case True{}:
1323	      gc.n183(U32.is_lt(c, 389), c)
1324	    case False{}:
1325	      gc.n187(U32.is_lt(c, 396), c)
1326	
1327	def gc.n189(lt: Bool, +c: U32) -> String:
1328	  match lt:
1329	    case True{}:
1330	      gc.n180(U32.is_lt(c, 380), c)
1331	    case False{}:
1332	      gc.n188(U32.is_lt(c, 392), c)
1333	
1334	def gc.n190(lt: Bool, +c: U32) -> String:
1335	  match lt:
1336	    case True{}:
1337	      gc.n173(U32.is_lt(c, 367), c)
1338	    case False{}:
1339	      gc.n189(U32.is_lt(c, 387), c)
1340	
1341	def gc.n191(lt: Bool, +c: U32) -> String:
1342	  match lt:
1343	    case True{}:
1344	      gc.n158(U32.is_lt(c, 343), c)
1345	    case False{}:
1346	      gc.n190(U32.is_lt(c, 375), c)
1347	
1348	def gc.n192(lt: Bool, +c: U32) -> String:
1349	  match lt:
1350	    case True{}:
1351	      "Lu"
1352	    case False{}:
1353	      "Ll"
1354	
1355	def gc.n193(lt: Bool, +c: U32) -> String:
1356	  match lt:
1357	    case True{}:
1358	      "Lu"
1359	    case False{}:
1360	      "Ll"
1361	
1362	def gc.n194(lt: Bool, +c: U32) -> String:
1363	  match lt:
1364	    case True{}:
1365	      gc.n192(U32.is_lt(c, 405), c)
1366	    case False{}:
1367	      gc.n193(U32.is_lt(c, 409), c)
1368	
1369	def gc.n195(lt: Bool, +c: U32) -> String:
1370	  match lt:
1371	    case True{}:
1372	      "Lu"
1373	    case False{}:
1374	      "Ll"
1375	
1376	def gc.n196(lt: Bool, +c: U32) -> String:
1377	  match lt:
1378	    case True{}:
1379	      "Lu"
1380	    case False{}:
1381	      "Ll"
1382	
1383	def gc.n197(lt: Bool, +c: U32) -> String:
1384	  match lt:
1385	    case True{}:
1386	      gc.n195(U32.is_lt(c, 414), c)
1387	    case False{}:
1388	      gc.n196(U32.is_lt(c, 417), c)
1389	
1390	def gc.n198(lt: Bool, +c: U32) -> String:
1391	  match lt:
1392	    case True{}:
1393	      gc.n194(U32.is_lt(c, 406), c)
1394	    case False{}:
1395	      gc.n197(U32.is_lt(c, 415), c)
1396	
1397	def gc.n199(lt: Bool, +c: U32) -> String:
1398	  match lt:
1399	    case True{}:
1400	      "Lu"
1401	    case False{}:
1402	      "Ll"
1403	
1404	def gc.n200(lt: Bool, +c: U32) -> String:
1405	  match lt:
1406	    case True{}:
1407	      "Lu"
1408	    case False{}:
1409	      "Ll"
1410	
1411	def gc.n201(lt: Bool, +c: U32) -> String:
1412	  match lt:
1413	    case True{}:
1414	      gc.n199(U32.is_lt(c, 419), c)
1415	    case False{}:
1416	      gc.n200(U32.is_lt(c, 421), c)
1417	
1418	def gc.n202(lt: Bool, +c: U32) -> String:
1419	  match lt:
1420	    case True{}:
1421	      "Lu"
1422	    case False{}:
1423	      "Ll"
1424	
1425	def gc.n203(lt: Bool, +c: U32) -> String:
1426	  match lt:
1427	    case True{}:
1428	      "Lu"
1429	    case False{}:
1430	      "Ll"
1431	
1432	def gc.n204(lt: Bool, +c: U32) -> String:
1433	  match lt:
1434	    case True{}:
1435	      gc.n202(U32.is_lt(c, 424), c)
1436	    case False{}:
1437	      gc.n203(U32.is_lt(c, 426), c)
1438	
1439	def gc.n205(lt: Bool, +c: U32) -> String:
1440	  match lt:
1441	    case True{}:
1442	      gc.n201(U32.is_lt(c, 420), c)
1443	    case False{}:
1444	      gc.n204(U32.is_lt(c, 425), c)
1445	
1446	def gc.n206(lt: Bool, +c: U32) -> String:
1447	  match lt:
1448	    case True{}:
1449	      gc.n198(U32.is_lt(c, 412), c)
1450	    case False{}:
1451	      gc.n205(U32.is_lt(c, 422), c)
1452	
1453	def gc.n207(lt: Bool, +c: U32) -> String:
1454	  match lt:
1455	    case True{}:
1456	      "Lu"
1457	    case False{}:
1458	      "Ll"
1459	
1460	def gc.n208(lt: Bool, +c: U32) -> String:
1461	  match lt:
1462	    case True{}:
1463	      "Lu"
1464	    case False{}:
1465	      "Ll"
1466	
1467	def gc.n209(lt: Bool, +c: U32) -> String:
1468	  match lt:
1469	    case True{}:
1470	      gc.n207(U32.is_lt(c, 429), c)
1471	    case False{}:
1472	      gc.n208(U32.is_lt(c, 432), c)
1473	
1474	def gc.n210(lt: Bool, +c: U32) -> String:
1475	  match lt:
1476	    case True{}:
1477	      "Lu"
1478	    case False{}:
1479	      "Ll"
1480	
1481	def gc.n211(lt: Bool, +c: U32) -> String:
1482	  match lt:
1483	    case True{}:
1484	      "Lu"
1485	    case False{}:
1486	      "Ll"
1487	
1488	def gc.n212(lt: Bool, +c: U32) -> String:
1489	  match lt:
1490	    case True{}:
1491	      gc.n210(U32.is_lt(c, 436), c)
1492	    case False{}:
1493	      gc.n211(U32.is_lt(c, 438), c)
1494	
1495	def gc.n213(lt: Bool, +c: U32) -> String:
1496	  match lt:
1497	    case True{}:
1498	      gc.n209(U32.is_lt(c, 430), c)
1499	    case False{}:
1500	      gc.n212(U32.is_lt(c, 437), c)
1501	
1502	def gc.n214(lt: Bool, +c: U32) -> String:
1503	  match lt:
1504	    case True{}:
1505	      "Lu"
1506	    case False{}:
1507	      "Ll"
1508	
1509	def gc.n215(lt: Bool, +c: U32) -> String:
1510	  match lt:
1511	    case True{}:
1512	      "Lo"
1513	    case False{}:
1514	      "Lu"
1515	
1516	def gc.n216(lt: Bool, +c: U32) -> String:
1517	  match lt:
1518	    case True{}:
1519	      gc.n214(U32.is_lt(c, 441), c)
1520	    case False{}:
1521	      gc.n215(U32.is_lt(c, 444), c)
1522	
1523	def gc.n217(lt: Bool, +c: U32) -> String:
1524	  match lt:
1525	    case True{}:
1526	      "Ll"
1527	    case False{}:
1528	      "Lo"
1529	
1530	def gc.n218(lt: Bool, +c: U32) -> String:
1531	  match lt:
1532	    case True{}:
1533	      "Lu"
1534	    case False{}:
1535	      "Lt"
1536	
1537	def gc.n219(lt: Bool, +c: U32) -> String:
1538	  match lt:
1539	    case True{}:
1540	      gc.n217(U32.is_lt(c, 448), c)
1541	    case False{}:
1542	      gc.n218(U32.is_lt(c, 453), c)
1543	
1544	def gc.n220(lt: Bool, +c: U32) -> String:
1545	  match lt:
1546	    case True{}:
1547	      gc.n216(U32.is_lt(c, 443), c)
1548	    case False{}:
1549	      gc.n219(U32.is_lt(c, 452), c)
1550	
1551	def gc.n221(lt: Bool, +c: U32) -> String:
1552	  match lt:
1553	    case True{}:
1554	      gc.n213(U32.is_lt(c, 433), c)
1555	    case False{}:
1556	      gc.n220(U32.is_lt(c, 445), c)
1557	
1558	def gc.n222(lt: Bool, +c: U32) -> String:
1559	  match lt:
1560	    case True{}:
1561	      gc.n206(U32.is_lt(c, 418), c)
1562	    case False{}:
1563	      gc.n221(U32.is_lt(c, 439), c)
1564	
1565	def gc.n223(lt: Bool, +c: U32) -> String:
1566	  match lt:
1567	    case True{}:
1568	      "Ll"
1569	    case False{}:
1570	      "Lu"
1571	
1572	def gc.n224(lt: Bool, +c: U32) -> String:
1573	  match lt:
1574	    case True{}:
1575	      "Lt"
1576	    case False{}:
1577	      "Ll"
1578	
1579	def gc.n225(lt: Bool, +c: U32) -> String:
1580	  match lt:
1581	    case True{}:
1582	      gc.n223(U32.is_lt(c, 455), c)
1583	    case False{}:
1584	      gc.n224(U32.is_lt(c, 457), c)
1585	
1586	def gc.n226(lt: Bool, +c: U32) -> String:
1587	  match lt:
1588	    case True{}:
1589	      "Lu"
1590	    case False{}:
1591	      "Lt"
1592	
1593	def gc.n227(lt: Bool, +c: U32) -> String:
1594	  match lt:
1595	    case True{}:
1596	      "Ll"
1597	    case False{}:
1598	      "Lu"
1599	
1600	def gc.n228(lt: Bool, +c: U32) -> String:
1601	  match lt:
1602	    case True{}:
1603	      gc.n226(U32.is_lt(c, 459), c)
1604	    case False{}:
1605	      gc.n227(U32.is_lt(c, 461), c)
1606	
1607	def gc.n229(lt: Bool, +c: U32) -> String:
1608	  match lt:
1609	    case True{}:
1610	      gc.n225(U32.is_lt(c, 456), c)
1611	    case False{}:
1612	      gc.n228(U32.is_lt(c, 460), c)
1613	
1614	def gc.n230(lt: Bool, +c: U32) -> String:
1615	  match lt:
1616	    case True{}:
1617	      "Ll"
1618	    case False{}:
1619	      "Lu"
1620	
1621	def gc.n231(lt: Bool, +c: U32) -> String:
1622	  match lt:
1623	    case True{}:
1624	      "Ll"
1625	    case False{}:
1626	      "Lu"
1627	
1628	def gc.n232(lt: Bool, +c: U32) -> String:
1629	  match lt:
1630	    case True{}:
1631	      gc.n230(U32.is_lt(c, 463), c)
1632	    case False{}:
1633	      gc.n231(U32.is_lt(c, 465), c)
1634	
1635	def gc.n233(lt: Bool, +c: U32) -> String:
1636	  match lt:
1637	    case True{}:
1638	      "Ll"
1639	    case False{}:
1640	      "Lu"
1641	
1642	def gc.n234(lt: Bool, +c: U32) -> String:
1643	  match lt:
1644	    case True{}:
1645	      "Ll"
1646	    case False{}:
1647	      "Lu"
1648	
1649	def gc.n235(lt: Bool, +c: U32) -> String:
1650	  match lt:
1651	    case True{}:
1652	      gc.n233(U32.is_lt(c, 467), c)
1653	    case False{}:
1654	      gc.n234(U32.is_lt(c, 469), c)
1655	
1656	def gc.n236(lt: Bool, +c: U32) -> String:
1657	  match lt:
1658	    case True{}:
1659	      gc.n232(U32.is_lt(c, 464), c)
1660	    case False{}:
1661	      gc.n235(U32.is_lt(c, 468), c)
1662	
1663	def gc.n237(lt: Bool, +c: U32) -> String:
1664	  match lt:
1665	    case True{}:
1666	      gc.n229(U32.is_lt(c, 458), c)
1667	    case False{}:
1668	      gc.n236(U32.is_lt(c, 466), c)
1669	
1670	def gc.n238(lt: Bool, +c: U32) -> String:
1671	  match lt:
1672	    case True{}:
1673	      "Ll"
1674	    case False{}:
1675	      "Lu"
1676	
1677	def gc.n239(lt: Bool, +c: U32) -> String:
1678	  match lt:
1679	    case True{}:
1680	      "Ll"
1681	    case False{}:
1682	      "Lu"
1683	
1684	def gc.n240(lt: Bool, +c: U32) -> String:
1685	  match lt:
1686	    case True{}:
1687	      gc.n238(U32.is_lt(c, 471), c)
1688	    case False{}:
1689	      gc.n239(U32.is_lt(c, 473), c)
1690	
1691	def gc.n241(lt: Bool, +c: U32) -> String:
1692	  match lt:
1693	    case True{}:
1694	      "Ll"
1695	    case False{}:
1696	      "Lu"
1697	
1698	def gc.n242(lt: Bool, +c: U32) -> String:
1699	  match lt:
1700	    case True{}:
1701	      "Ll"
1702	    case False{}:
1703	      "Lu"
1704	
1705	def gc.n243(lt: Bool, +c: U32) -> String:
1706	  match lt:
1707	    case True{}:
1708	      gc.n241(U32.is_lt(c, 475), c)
1709	    case False{}:
1710	      gc.n242(U32.is_lt(c, 478), c)
1711	
1712	def gc.n244(lt: Bool, +c: U32) -> String:
1713	  match lt:
1714	    case True{}:
1715	      gc.n240(U32.is_lt(c, 472), c)
1716	    case False{}:
1717	      gc.n243(U32.is_lt(c, 476), c)
1718	
1719	def gc.n245(lt: Bool, +c: U32) -> String:
1720	  match lt:
1721	    case True{}:
1722	      "Ll"
1723	    case False{}:
1724	      "Lu"
1725	
1726	def gc.n246(lt: Bool, +c: U32) -> String:
1727	  match lt:
1728	    case True{}:
1729	      "Ll"
1730	    case False{}:
1731	      "Lu"
1732	
1733	def gc.n247(lt: Bool, +c: U32) -> String:
1734	  match lt:
1735	    case True{}:
1736	      gc.n245(U32.is_lt(c, 480), c)
1737	    case False{}:
1738	      gc.n246(U32.is_lt(c, 482), c)
1739	
1740	def gc.n248(lt: Bool, +c: U32) -> String:
1741	  match lt:
1742	    case True{}:
1743	      "Ll"
1744	    case False{}:
1745	      "Lu"
1746	
1747	def gc.n249(lt: Bool, +c: U32) -> String:
1748	  match lt:
1749	    case True{}:
1750	      "Lu"
1751	    case False{}:
1752	      "Ll"
1753	
1754	def gc.n250(lt: Bool, +c: U32) -> String:
1755	  match lt:
1756	    case True{}:
1757	      "Ll"
1758	    case False{}:
1759	      gc.n249(U32.is_lt(c, 487), c)
1760	
1761	def gc.n251(lt: Bool, +c: U32) -> String:
1762	  match lt:
1763	    case True{}:
1764	      gc.n248(U32.is_lt(c, 484), c)
1765	    case False{}:
1766	      gc.n250(U32.is_lt(c, 486), c)
1767	
1768	def gc.n252(lt: Bool, +c: U32) -> String:
1769	  match lt:
1770	    case True{}:
1771	      gc.n247(U32.is_lt(c, 481), c)
1772	    case False{}:
1773	      gc.n251(U32.is_lt(c, 485), c)
1774	
1775	def gc.n253(lt: Bool, +c: U32) -> String:
1776	  match lt:
1777	    case True{}:
1778	      gc.n244(U32.is_lt(c, 474), c)
1779	    case False{}:
1780	      gc.n252(U32.is_lt(c, 483), c)
1781	
1782	def gc.n254(lt: Bool, +c: U32) -> String:
1783	  match lt:
1784	    case True{}:
1785	      gc.n237(U32.is_lt(c, 462), c)
1786	    case False{}:
1787	      gc.n253(U32.is_lt(c, 479), c)
1788	
1789	def gc.n255(lt: Bool, +c: U32) -> String:
1790	  match lt:
1791	    case True{}:
1792	      gc.n222(U32.is_lt(c, 428), c)
1793	    case False{}:
1794	      gc.n254(U32.is_lt(c, 470), c)
1795	
1796	def gc.n256(lt: Bool, +c: U32) -> String:
1797	  match lt:
1798	    case True{}:
1799	      gc.n191(U32.is_lt(c, 359), c)
1800	    case False{}:
1801	      gc.n255(U32.is_lt(c, 454), c)
1802	
1803	def gc.n257(lt: Bool, +c: U32) -> String:
1804	  match lt:
1805	    case True{}:
1806	      gc.n127(U32.is_lt(c, 260), c)
1807	    case False{}:
1808	      gc.n256(U32.is_lt(c, 403), c)
1809	
1810	def gc.n258(lt: Bool, +c: U32) -> String:
1811	  match lt:
1812	    case True{}:
1813	      "Lu"
1814	    case False{}:
1815	      "Ll"
1816	
1817	def gc.n259(lt: Bool, +c: U32) -> String:
1818	  match lt:
1819	    case True{}:
1820	      "Lu"
1821	    case False{}:
1822	      "Ll"
1823	
1824	def gc.n260(lt: Bool, +c: U32) -> String:
1825	  match lt:
1826	    case True{}:
1827	      gc.n258(U32.is_lt(c, 489), c)
1828	    case False{}:
1829	      gc.n259(U32.is_lt(c, 491), c)
1830	
1831	def gc.n261(lt: Bool, +c: U32) -> String:
1832	  match lt:
1833	    case True{}:
1834	      "Lu"
1835	    case False{}:
1836	      "Ll"
1837	
1838	def gc.n262(lt: Bool, +c: U32) -> String:
1839	  match lt:
1840	    case True{}:
1841	      "Lu"
1842	    case False{}:
1843	      "Ll"
1844	
1845	def gc.n263(lt: Bool, +c: U32) -> String:
1846	  match lt:
1847	    case True{}:
1848	      gc.n261(U32.is_lt(c, 493), c)
1849	    case False{}:
1850	      gc.n262(U32.is_lt(c, 495), c)
1851	
1852	def gc.n264(lt: Bool, +c: U32) -> String:
1853	  match lt:
1854	    case True{}:
1855	      gc.n260(U32.is_lt(c, 490), c)
1856	    case False{}:
1857	      gc.n263(U32.is_lt(c, 494), c)
1858	
1859	def gc.n265(lt: Bool, +c: U32) -> String:
1860	  match lt:
1861	    case True{}:
1862	      "Lu"
1863	    case False{}:
1864	      "Lt"
1865	
1866	def gc.n266(lt: Bool, +c: U32) -> String:
1867	  match lt:
1868	    case True{}:
1869	      "Ll"
1870	    case False{}:
1871	      "Lu"
1872	
1873	def gc.n267(lt: Bool, +c: U32) -> String:
1874	  match lt:
1875	    case True{}:
1876	      gc.n265(U32.is_lt(c, 498), c)
1877	    case False{}:
1878	      gc.n266(U32.is_lt(c, 500), c)
1879	
1880	def gc.n268(lt: Bool, +c: U32) -> String:
1881	  match lt:
1882	    case True{}:
1883	      "Ll"
1884	    case False{}:
1885	      "Lu"
1886	
1887	def gc.n269(lt: Bool, +c: U32) -> String:
1888	  match lt:
1889	    case True{}:
1890	      "Ll"
1891	    case False{}:
1892	      "Lu"
1893	
1894	def gc.n270(lt: Bool, +c: U32) -> String:
1895	  match lt:
1896	    case True{}:
1897	      gc.n268(U32.is_lt(c, 502), c)
1898	    case False{}:
1899	      gc.n269(U32.is_lt(c, 506), c)
1900	
1901	def gc.n271(lt: Bool, +c: U32) -> String:
1902	  match lt:
1903	    case True{}:
1904	      gc.n267(U32.is_lt(c, 499), c)
1905	    case False{}:
1906	      gc.n270(U32.is_lt(c, 505), c)
1907	
1908	def gc.n272(lt: Bool, +c: U32) -> String:
1909	  match lt:
1910	    case True{}:
1911	      gc.n264(U32.is_lt(c, 492), c)
1912	    case False{}:
1913	      gc.n271(U32.is_lt(c, 501), c)
1914	
1915	def gc.n273(lt: Bool, +c: U32) -> String:
1916	  match lt:
1917	    case True{}:
1918	      "Ll"
1919	    case False{}:
1920	      "Lu"
1921	
1922	def gc.n274(lt: Bool, +c: U32) -> String:
1923	  match lt:
1924	    case True{}:
1925	      "Ll"
1926	    case False{}:
1927	      "Lu"
1928	
1929	def gc.n275(lt: Bool, +c: U32) -> String:
1930	  match lt:
1931	    case True{}:
1932	      gc.n273(U32.is_lt(c, 508), c)
1933	    case False{}:
1934	      gc.n274(U32.is_lt(c, 510), c)
1935	
1936	def gc.n276(lt: Bool, +c: U32) -> String:
1937	  match lt:
1938	    case True{}:
1939	      "Ll"
1940	    case False{}:
1941	      "Lu"
1942	
1943	def gc.n277(lt: Bool, +c: U32) -> String:
1944	  match lt:
1945	    case True{}:
1946	      "Ll"
1947	    case False{}:
1948	      "Lu"
1949	
1950	def gc.n278(lt: Bool, +c: U32) -> String:
1951	  match lt:
1952	    case True{}:
1953	      gc.n276(U32.is_lt(c, 512), c)
1954	    case False{}:
1955	      gc.n277(U32.is_lt(c, 514), c)
1956	
1957	def gc.n279(lt: Bool, +c: U32) -> String:
1958	  match lt:
1959	    case True{}:
1960	      gc.n275(U32.is_lt(c, 509), c)
1961	    case False{}:
1962	      gc.n278(U32.is_lt(c, 513), c)
1963	
1964	def gc.n280(lt: Bool, +c: U32) -> String:
1965	  match lt:
1966	    case True{}:
1967	      "Ll"
1968	    case False{}:
1969	      "Lu"
1970	
1971	def gc.n281(lt: Bool, +c: U32) -> String:
1972	  match lt:
1973	    case True{}:
1974	      "Ll"
1975	    case False{}:
1976	      "Lu"
1977	
1978	def gc.n282(lt: Bool, +c: U32) -> String:
1979	  match lt:
1980	    case True{}:
1981	      gc.n280(U32.is_lt(c, 516), c)
1982	    case False{}:
1983	      gc.n281(U32.is_lt(c, 518), c)
1984	
1985	def gc.n283(lt: Bool, +c: U32) -> String:
1986	  match lt:
1987	    case True{}:
1988	      "Ll"
1989	    case False{}:
1990	      "Lu"
1991	
1992	def gc.n284(lt: Bool, +c: U32) -> String:
1993	  match lt:
1994	    case True{}:
1995	      "Ll"
1996	    case False{}:
1997	      "Lu"
1998	
1999	def gc.n285(lt: Bool, +c: U32) -> String:
2000	  match lt:
Lines 1-2000 of 92545. More: https://jend.leeeet.dev/read.txt?path=bend-kit-unicode@0.1.0.0/tables.bend&start_line=2001