OXIESEC PANEL

Name	Size	Modified	Perms
📁 ..	-	03/12/2026 01:54:05 PM	rwxr-xr-x
📄 GET	15.82 KB	03/25/2022 08:00:31 AM	rwxr-xr-x
📄 Mail	0 bytes	01/01/1970 12:00:00 AM	---------
📄 [	51.8 KB	03/12/2025 12:52:26 PM	rwxr-xr-x
📄 aclocal	35.52 KB	09/27/2023 12:16:24 PM	rwxr-xr-x
📄 aclocal-1.16	35.52 KB	09/27/2023 12:16:24 PM	rwxr-xr-x
📄 addr2line	27.74 KB	03/31/2025 10:32:50 AM	rwxr-xr-x
📄 animate	15.27 KB	04/01/2025 12:55:20 PM	rwxr-xr-x
📄 ar	55.98 KB	03/31/2025 10:32:50 AM	rwxr-xr-x
📄 arch	31.66 KB	03/12/2025 12:52:26 PM	rwxr-xr-x
📄 arpaname	15.11 KB	11/10/2025 03:35:46 AM	rwxr-xr-x
📄 as	710.31 KB	03/31/2025 10:32:50 AM	rwxr-xr-x
📄 aspell	151.12 KB	01/26/2022 09:47:25 PM	rwxr-xr-x
📄 at	1.02 KB	08/05/2025 06:15:39 AM	rwxr-xr-x
📄 atq	1.02 KB	08/05/2025 06:15:39 AM	rwxr-xr-x
📄 atrm	1.02 KB	08/05/2025 06:15:39 AM	rwxr-xr-x
📄 autoconf	14.42 KB	10/02/2024 08:06:28 PM	rwxr-xr-x
📄 autoheader	8.33 KB	10/02/2024 08:06:28 PM	rwxr-xr-x
📄 autom4te	31.43 KB	10/02/2024 08:06:28 PM	rwxr-xr-x
📄 automake	251.93 KB	09/27/2023 12:16:24 PM	rwxr-xr-x
📄 automake-1.16	251.93 KB	09/27/2023 12:16:24 PM	rwxr-xr-x
📄 autoreconf	20.57 KB	10/02/2024 08:06:28 PM	rwxr-xr-x
📄 autoscan	16.72 KB	10/02/2024 08:06:28 PM	rwxr-xr-x
📄 autoupdate	33.08 KB	10/02/2024 08:06:28 PM	rwxr-xr-x
📄 awk	698.17 KB	03/30/2022 10:25:28 PM	rwxr-xr-x
📄 b2sum	51.79 KB	03/12/2025 12:52:26 PM	rwxr-xr-x
📄 base32	35.69 KB	03/12/2025 12:52:26 PM	rwxr-xr-x
📄 base64	35.7 KB	03/12/2025 12:52:26 PM	rwxr-xr-x
📄 basename	35.67 KB	03/12/2025 12:52:26 PM	rwxr-xr-x
📄 basenc	48.02 KB	03/12/2025 12:52:26 PM	rwxr-xr-x
📄 bash	1.32 MB	04/30/2024 02:33:56 PM	rwxr-xr-x
📄 bashbug-64	6.91 KB	04/30/2024 02:33:47 PM	rwxr-xr-x
📄 batch	140 bytes	08/05/2025 06:15:38 AM	rwxr-xr-x
📄 bison	494.76 KB	01/27/2022 12:15:31 AM	rwxr-xr-x
📄 bunzip2	39.62 KB	02/04/2025 03:42:48 AM	rwxr-xr-x
📄 bzcat	39.62 KB	02/04/2025 03:42:48 AM	rwxr-xr-x
📄 bzcmp	2.09 KB	02/04/2025 03:42:48 AM	rwxr-xr-x
📄 bzdiff	2.09 KB	02/04/2025 03:42:48 AM	rwxr-xr-x
📄 bzgrep	2.01 KB	02/04/2025 03:42:48 AM	rwxr-xr-x
📄 bzip2	39.62 KB	02/04/2025 03:42:48 AM	rwxr-xr-x
📄 bzip2recover	15.4 KB	02/04/2025 03:42:48 AM	rwxr-xr-x
📄 bzless	1.23 KB	02/04/2025 03:42:48 AM	rwxr-xr-x
📄 bzmore	1.23 KB	02/04/2025 03:42:48 AM	rwxr-xr-x
📄 c++	1.04 MB	02/12/2025 01:11:11 PM	rwxr-xr-x
📄 c++filt	27.18 KB	03/31/2025 10:32:50 AM	rwxr-xr-x
📄 c89	228 bytes	02/12/2025 01:07:17 PM	rwxr-xr-x
📄 c99	219 bytes	02/12/2025 01:07:17 PM	rwxr-xr-x
📄 cagefs_enter.proxied	1.04 KB	05/26/2025 11:09:33 AM	rwxr-xr-x
📄 cal	52.01 KB	03/13/2025 06:30:13 AM	rwxr-xr-x
📄 captoinfo	87.8 KB	08/05/2025 09:46:00 AM	rwxr-xr-x
📄 cat	35.66 KB	03/12/2025 12:52:26 PM	rwxr-xr-x
📄 catchsegv	3.21 KB	11/05/2025 09:31:15 AM	rwxr-xr-x
📄 cc	1.04 MB	02/12/2025 01:11:11 PM	rwxr-xr-x
📄 chcon	60.24 KB	03/12/2025 12:52:26 PM	rwxr-xr-x
📄 chgrp	56.19 KB	03/12/2025 12:52:26 PM	rwxr-xr-x
📄 chmod	56.16 KB	03/12/2025 12:52:26 PM	rwxr-xr-x
📄 chown	60.19 KB	03/12/2025 12:52:26 PM	rwxr-xr-x
📄 chrt	27.48 KB	03/13/2025 06:30:13 AM	rwxr-xr-x
📄 cksum	35.57 KB	03/12/2025 12:52:26 PM	rwxr-xr-x
📄 cldetect	10.35 KB	09/29/2025 11:30:11 PM	rwxr-xr-x
📄 clear	15.16 KB	08/05/2025 09:46:00 AM	rwxr-xr-x
📄 cloudlinux-awp-user	1.78 KB	07/02/2025 03:43:45 PM	rwxr-xr-x
📄 clwpos-user	1.78 KB	07/02/2025 03:43:45 PM	rwxr-xr-x
📄 cmp	40.13 KB	01/29/2022 06:15:51 PM	rwxr-xr-x
📄 col	23.41 KB	03/13/2025 06:30:13 AM	rwxr-xr-x
📄 colcrt	15.38 KB	03/13/2025 06:30:13 AM	rwxr-xr-x
📄 colrm	15.36 KB	03/13/2025 06:30:13 AM	rwxr-xr-x
📄 column	35.52 KB	03/13/2025 06:30:13 AM	rwxr-xr-x
📄 comm	35.75 KB	03/12/2025 12:52:26 PM	rwxr-xr-x
📄 compare	15.27 KB	04/01/2025 12:55:20 PM	rwxr-xr-x
📄 composite	15.27 KB	04/01/2025 12:55:20 PM	rwxr-xr-x
📄 conjure	15.27 KB	04/01/2025 12:55:20 PM	rwxr-xr-x
📄 convert	15.27 KB	04/01/2025 12:55:20 PM	rwxr-xr-x
📄 cp	149.24 KB	03/12/2025 12:52:26 PM	rwxr-xr-x
📄 cpan	8.37 KB	05/13/2025 09:00:14 PM	rwxr-xr-x
📄 cpp	1.04 MB	02/12/2025 01:11:11 PM	rwxr-xr-x
📄 crontab	1.49 KB	08/05/2025 06:13:26 AM	rwxr-xr-x
📄 crontab.cagefs	40.47 KB	06/23/2025 12:21:56 PM	rwxr-xr-x
📄 csplit	108.88 KB	03/12/2025 12:52:26 PM	rwxr-xr-x
📄 curl	248.49 KB	08/05/2025 06:19:17 AM	rwxr-xr-x
📄 cut	47.8 KB	03/12/2025 12:52:26 PM	rwxr-xr-x
📄 cyrusbdb2current	1.58 MB	04/10/2023 02:10:39 PM	rwxr-xr-x
📄 date	104.05 KB	03/12/2025 12:52:26 PM	rwxr-xr-x
📄 dd	68.14 KB	03/12/2025 12:52:26 PM	rwxr-xr-x
📄 delv	45.38 KB	11/10/2025 03:35:46 AM	rwxr-xr-x
📄 df	84.73 KB	03/12/2025 12:52:26 PM	rwxr-xr-x
📄 diff	194.7 KB	01/29/2022 06:15:51 PM	rwxr-xr-x
📄 diff3	52.3 KB	01/29/2022 06:15:51 PM	rwxr-xr-x
📄 dig	136.59 KB	11/10/2025 03:35:46 AM	rwxr-xr-x
📄 dir	137.65 KB	03/12/2025 12:52:26 PM	rwxr-xr-x
📄 dircolors	39.8 KB	03/12/2025 12:52:26 PM	rwxr-xr-x
📄 dirname	31.48 KB	03/12/2025 12:52:26 PM	rwxr-xr-x
📄 display	15.27 KB	04/01/2025 12:55:20 PM	rwxr-xr-x
📄 dnstap-read	23.19 KB	11/10/2025 03:35:46 AM	rwxr-xr-x
📄 du	149.44 KB	03/12/2025 12:52:26 PM	rwxr-xr-x
📄 echo	35.48 KB	03/12/2025 12:52:26 PM	rwxr-xr-x
📄 ed	52.51 KB	01/30/2022 05:02:01 AM	rwxr-xr-x
📄 egrep	32 bytes	01/31/2022 08:22:32 PM	rwxr-xr-x
📄 enc2xs	40.69 KB	02/11/2022 04:42:02 PM	rwxr-xr-x
📄 enchant	23.73 KB	01/30/2022 11:02:06 AM	rwxr-xr-x
📄 enchant-lsmod	15.8 KB	01/30/2022 11:02:06 AM	rwxr-xr-x
📄 env	44.23 KB	03/12/2025 12:52:26 PM	rwxr-xr-x
📄 eps2eps	643 bytes	05/14/2025 04:03:24 PM	rwxr-xr-x
📄 eqn	189.52 KB	02/01/2022 10:44:53 AM	rwxr-xr-x
📄 ex	1.38 MB	10/14/2025 09:11:29 AM	rwxr-xr-x
📄 expand	39.73 KB	03/12/2025 12:52:26 PM	rwxr-xr-x
📄 expr	108.6 KB	03/12/2025 12:52:26 PM	rwxr-xr-x
📄 factor	72.05 KB	03/12/2025 12:52:26 PM	rwxr-xr-x
📄 false	27.47 KB	03/12/2025 12:52:26 PM	rwxr-xr-x
📄 fc-cache	139 bytes	01/23/2023 03:48:20 PM	rwxr-xr-x
📄 fc-cache-64	23.17 KB	01/23/2023 07:48:35 PM	rwxr-xr-x
📄 fc-cat	19.16 KB	01/23/2023 07:48:35 PM	rwxr-xr-x
📄 fc-conflist	15.13 KB	01/23/2023 07:48:35 PM	rwxr-xr-x
📄 fc-list	15.13 KB	01/23/2023 07:48:35 PM	rwxr-xr-x
📄 fc-match	15.13 KB	01/23/2023 07:48:35 PM	rwxr-xr-x
📄 fc-pattern	15.14 KB	01/23/2023 07:48:35 PM	rwxr-xr-x
📄 fc-query	15.13 KB	01/23/2023 07:48:35 PM	rwxr-xr-x
📄 fc-scan	15.14 KB	01/23/2023 07:48:35 PM	rwxr-xr-x
📄 fc-validate	15.14 KB	01/23/2023 07:48:35 PM	rwxr-xr-x
📄 fgrep	32 bytes	01/31/2022 08:22:32 PM	rwxr-xr-x
📄 file	27.74 KB	04/03/2024 12:38:13 PM	rwxr-xr-x
📄 find	284.95 KB	10/02/2024 09:04:59 PM	rwxr-xr-x
📄 flex	412.64 KB	01/30/2022 08:23:38 AM	rwxr-xr-x
📄 flex++	412.64 KB	01/30/2022 08:23:38 AM	rwxr-xr-x
📄 flock	23.56 KB	03/13/2025 06:30:13 AM	rwxr-xr-x
📄 fmt	39.77 KB	03/12/2025 12:52:26 PM	rwxr-xr-x
📄 fold	39.71 KB	03/12/2025 12:52:26 PM	rwxr-xr-x
📄 free	23.36 KB	04/30/2024 04:43:23 PM	rwxr-xr-x
📄 freetype-config	4.32 KB	03/31/2025 03:40:24 PM	rwxr-xr-x
📄 funzip	31.42 KB	03/18/2025 03:53:48 AM	rwxr-xr-x
📄 g++	1.04 MB	02/12/2025 01:11:11 PM	rwxr-xr-x
📄 gawk	698.17 KB	03/30/2022 10:25:28 PM	rwxr-xr-x
📄 gcc	1.04 MB	02/12/2025 01:11:11 PM	rwxr-xr-x
📄 gcc-ar	27.81 KB	02/12/2025 01:11:11 PM	rwxr-xr-x
📄 gcc-nm	27.8 KB	02/12/2025 01:11:11 PM	rwxr-xr-x
📄 gcc-ranlib	27.82 KB	02/12/2025 01:11:11 PM	rwxr-xr-x
📄 gcov	468.98 KB	02/12/2025 01:11:12 PM	rwxr-xr-x
📄 gcov-dump	283.74 KB	02/12/2025 01:11:12 PM	rwxr-xr-x
📄 gcov-tool	312.46 KB	02/12/2025 01:11:12 PM	rwxr-xr-x
📄 gem	542 bytes	05/06/2025 04:04:18 AM	rwxr-xr-x
📄 gencat	27.45 KB	11/05/2025 09:33:47 AM	rwxr-xr-x
📄 geoiplookup	15.87 KB	11/23/2022 04:40:51 PM	rwxr-xr-x
📄 geoiplookup6	15.82 KB	11/23/2022 04:40:51 PM	rwxr-xr-x
📄 geqn	189.52 KB	02/01/2022 10:44:53 AM	rwxr-xr-x
📄 getconf	35.23 KB	11/05/2025 09:33:47 AM	rwxr-xr-x
📄 getent	35.86 KB	11/05/2025 09:33:47 AM	rwxr-xr-x
📄 getopt	23.45 KB	03/13/2025 06:30:13 AM	rwxr-xr-x
📄 ghostscript	15.13 KB	05/14/2025 04:03:33 PM	rwxr-xr-x
📄 git	4.06 MB	07/21/2025 04:25:54 PM	rwxr-xr-x
📄 git-receive-pack	4.06 MB	07/21/2025 04:25:54 PM	rwxr-xr-x
📄 git-shell	770.68 KB	07/21/2025 04:25:54 PM	rwxr-xr-x
📄 git-upload-archive	4.06 MB	07/21/2025 04:25:54 PM	rwxr-xr-x
📄 git-upload-pack	4.06 MB	07/21/2025 04:25:54 PM	rwxr-xr-x
📄 gm	15.67 KB	11/23/2022 05:49:37 PM	rwxr-xr-x
📄 gmake	249.8 KB	04/02/2024 12:55:30 PM	rwxr-xr-x
📄 gneqn	916 bytes	02/01/2022 10:44:38 AM	rwxr-xr-x
📄 gnroff	3.21 KB	02/01/2022 10:44:38 AM	rwxr-xr-x
📄 gpg	1.07 MB	09/26/2023 07:39:20 PM	rwxr-xr-x
📄 gpg-agent	342.25 KB	09/26/2023 07:39:20 PM	rwxr-xr-x
📄 gpg-error	36.1 KB	02/09/2022 11:24:31 PM	rwxr-xr-x
📄 gpgsplit	27.49 KB	09/26/2023 07:39:20 PM	rwxr-xr-x
📄 gpgv	295.42 KB	09/26/2023 07:39:20 PM	rwxr-xr-x
📄 gpic	201.72 KB	02/01/2022 10:44:53 AM	rwxr-xr-x
📄 gprof	101.48 KB	03/31/2025 10:32:50 AM	rwxr-xr-x
📄 grep	154.49 KB	01/31/2022 08:22:36 PM	rwxr-xr-x
📄 groff	96.77 KB	02/01/2022 10:44:53 AM	rwxr-xr-x
📄 grops	167.26 KB	02/01/2022 10:44:53 AM	rwxr-xr-x
📄 grotty	122.2 KB	02/01/2022 10:44:53 AM	rwxr-xr-x
📄 groups	35.66 KB	03/12/2025 12:52:26 PM	rwxr-xr-x
📄 gs	15.13 KB	05/14/2025 04:03:33 PM	rwxr-xr-x
📄 gsnd	281 bytes	05/14/2025 04:03:24 PM	rwxr-xr-x
📄 gsoelim	0 bytes	01/01/1970 12:00:00 AM	---------
📄 gtar	514.27 KB	10/02/2024 09:24:00 PM	rwxr-xr-x
📄 gtbl	130.86 KB	02/01/2022 10:44:53 AM	rwxr-xr-x
📄 gtroff	732.07 KB	02/01/2022 10:44:53 AM	rwxr-xr-x
📄 gunzip	2.29 KB	10/15/2022 05:26:34 PM	rwxr-xr-x
📄 gzexe	6.3 KB	10/15/2022 05:26:34 PM	rwxr-xr-x
📄 gzip	89.63 KB	10/15/2022 05:26:34 PM	rwxr-xr-x
📄 h2ph	28.69 KB	07/28/2025 03:54:48 AM	rwxr-xr-x
📄 h2xs	59.5 KB	07/28/2025 03:53:49 AM	rwxr-xr-x
📄 head	43.8 KB	03/12/2025 12:52:26 PM	rwxr-xr-x
📄 hexdump	51.59 KB	03/13/2025 06:30:13 AM	rwxr-xr-x
📄 host	108.58 KB	11/10/2025 03:35:46 AM	rwxr-xr-x
📄 hostid	31.66 KB	03/12/2025 12:52:26 PM	rwxr-xr-x
📄 hostname	23.84 KB	02/14/2022 11:22:04 AM	rwxr-xr-x
📄 hunspell	102.67 KB	01/31/2022 08:22:03 PM	rwxr-xr-x
📄 iconv	64.09 KB	11/05/2025 09:33:47 AM	rwxr-xr-x
📄 icu-config	205 bytes	07/29/2025 04:13:20 PM	rwxr-xr-x
📄 icu-config-64	21.67 KB	07/29/2025 04:16:01 PM	rwxr-xr-x
📄 icuinfo	15.49 KB	07/29/2025 04:17:08 PM	rwxr-xr-x
📄 id	39.71 KB	03/12/2025 12:52:26 PM	rwxr-xr-x
📄 identify	15.27 KB	04/01/2025 12:55:20 PM	rwxr-xr-x
📄 idn	36.46 KB	02/14/2022 03:33:03 PM	rwxr-xr-x
📄 ifnames	4.03 KB	10/02/2024 08:06:28 PM	rwxr-xr-x
📄 import	15.27 KB	04/01/2025 12:55:20 PM	rwxr-xr-x
📄 infocmp	63.69 KB	08/05/2025 09:46:00 AM	rwxr-xr-x
📄 infotocap	87.8 KB	08/05/2025 09:46:00 AM	rwxr-xr-x
📄 install	149.29 KB	03/12/2025 12:52:26 PM	rwxr-xr-x
📄 instmodsh	4.1 KB	02/24/2022 09:56:25 AM	rwxr-xr-x
📄 ionice	15.4 KB	03/13/2025 06:30:13 AM	rwxr-xr-x
📄 ipcrm	19.41 KB	03/13/2025 06:30:13 AM	rwxr-xr-x
📄 ipcs	39.52 KB	03/13/2025 06:30:13 AM	rwxr-xr-x
📄 isosize	15.34 KB	03/13/2025 06:30:13 AM	rwxr-xr-x
📄 ispell	992 bytes	10/08/2019 12:15:21 AM	rwxr-xr-x
📄 join	51.9 KB	03/12/2025 12:52:26 PM	rwxr-xr-x
📄 kill	31.47 KB	03/13/2025 06:30:13 AM	rwxr-xr-x
📄 ld	1.71 MB	03/31/2025 10:32:51 AM	rwxr-xr-x
📄 ld.bfd	1.71 MB	03/31/2025 10:32:51 AM	rwxr-xr-x
📄 ldd	5.32 KB	11/05/2025 09:31:17 AM	rwxr-xr-x
📄 less	197.9 KB	10/02/2024 08:38:47 PM	rwxr-xr-x
📄 lessecho	15.37 KB	10/02/2024 08:38:47 PM	rwxr-xr-x
📄 lesskey	24.8 KB	10/02/2024 08:38:47 PM	rwxr-xr-x
📄 lesspipe.sh	3.5 KB	10/02/2024 07:31:20 PM	rwxr-xr-x
📄 lex	412.64 KB	01/30/2022 08:23:38 AM	rwxr-xr-x
📄 libnetcfg	15.41 KB	07/28/2025 03:54:48 AM	rwxr-xr-x
📄 libtool	359.18 KB	10/01/2024 05:49:19 PM	rwxr-xr-x
📄 libtoolize	126.17 KB	10/01/2024 05:49:19 PM	rwxr-xr-x
📄 link	31.66 KB	03/12/2025 12:52:26 PM	rwxr-xr-x
📄 ln	60.16 KB	03/12/2025 12:52:26 PM	rwxr-xr-x
📄 locale	59.08 KB	11/05/2025 09:33:47 AM	rwxr-xr-x
📄 localedef	314.05 KB	11/05/2025 09:33:47 AM	rwxr-xr-x
📄 logger	36.16 KB	03/13/2025 06:30:13 AM	rwxr-xr-x
📄 login	43.62 KB	03/13/2025 06:30:13 AM	rwxr-xr-x
📄 logname	31.66 KB	03/12/2025 12:52:26 PM	rwxr-xr-x
📄 look	19.36 KB	03/13/2025 06:30:13 AM	rwxr-xr-x
📄 ls	137.64 KB	03/12/2025 12:52:26 PM	rwxr-xr-x
📄 lto-dump	26.58 MB	02/12/2025 01:11:12 PM	rwxr-xr-x
📄 m4	240.4 KB	03/31/2022 07:28:13 AM	rwxr-xr-x
📄 mail	0 bytes	01/01/1970 12:00:00 AM	---------
📄 mailx	0 bytes	01/01/1970 12:00:00 AM	---------
📄 make	249.8 KB	04/02/2024 12:55:30 PM	rwxr-xr-x
📄 make-dummy-cert	614 bytes	02/11/2025 09:56:48 PM	rwxr-xr-x
📄 mcookie	27.5 KB	03/13/2025 06:30:13 AM	rwxr-xr-x
📄 md5sum	39.64 KB	03/12/2025 12:52:26 PM	rwxr-xr-x
📄 mesg	15.33 KB	03/13/2025 06:30:13 AM	rwxr-xr-x
📄 mkdir	68.31 KB	03/12/2025 12:52:26 PM	rwxr-xr-x
📄 mkfifo	39.83 KB	03/12/2025 12:52:26 PM	rwxr-xr-x
📄 mknod	43.88 KB	03/12/2025 12:52:26 PM	rwxr-xr-x
📄 mktemp	39.8 KB	03/12/2025 12:52:26 PM	rwxr-xr-x
📄 mogrify	15.27 KB	04/01/2025 12:55:20 PM	rwxr-xr-x
📄 montage	15.27 KB	04/01/2025 12:55:20 PM	rwxr-xr-x
📄 more	43.63 KB	03/13/2025 06:30:13 AM	rwxr-xr-x
📄 mv	141.17 KB	03/12/2025 12:52:26 PM	rwxr-xr-x
📄 my_print_defaults	224.91 KB	09/24/2025 02:52:33 PM	rwxr-xr-x
📄 mysql	7.15 MB	09/24/2025 02:52:39 PM	rwxr-xr-x
📄 mysql_config	843 bytes	09/24/2025 02:05:53 PM	rwxr-xr-x
📄 mysql_config-64	4.93 KB	09/24/2025 02:05:52 PM	rwxr-xr-x
📄 mysqladmin	6.89 MB	09/24/2025 02:52:33 PM	rwxr-xr-x
📄 mysqlbinlog	7.19 MB	09/24/2025 02:52:36 PM	rwxr-xr-x
📄 mysqlcheck	6.9 MB	09/24/2025 02:52:36 PM	rwxr-xr-x
📄 mysqldump	6.97 MB	09/24/2025 02:52:33 PM	rwxr-xr-x
📄 mysqlimport	6.88 MB	09/24/2025 02:52:35 PM	rwxr-xr-x
📄 mysqlshow	6.87 MB	09/24/2025 02:52:39 PM	rwxr-xr-x
📄 namei	23.41 KB	03/13/2025 06:30:13 AM	rwxr-xr-x
📄 nano	346.2 KB	03/13/2025 03:12:50 AM	rwxr-xr-x
📄 neqn	916 bytes	02/01/2022 10:44:38 AM	rwxr-xr-x
📄 nice	35.67 KB	03/12/2025 12:52:26 PM	rwxr-xr-x
📄 nl	100.71 KB	03/12/2025 12:52:26 PM	rwxr-xr-x
📄 nm	44.71 KB	03/31/2025 10:32:51 AM	rwxr-xr-x
📄 nohup	35.58 KB	03/12/2025 12:52:26 PM	rwxr-xr-x
📄 nproc	35.69 KB	03/12/2025 12:52:26 PM	rwxr-xr-x
📄 nroff	3.21 KB	02/01/2022 10:44:38 AM	rwxr-xr-x
📄 nslookup	112.53 KB	11/10/2025 03:35:46 AM	rwxr-xr-x
📄 nsupdate	71.8 KB	11/10/2025 03:35:46 AM	rwxr-xr-x
📄 numfmt	55.83 KB	03/12/2025 12:52:26 PM	rwxr-xr-x
📄 objcopy	185.37 KB	03/31/2025 10:32:51 AM	rwxr-xr-x
📄 objdump	413.09 KB	03/31/2025 10:32:51 AM	rwxr-xr-x
📄 od	64.06 KB	03/12/2025 12:52:26 PM	rwxr-xr-x
📄 openssl	1.01 MB	02/11/2025 09:56:51 PM	rwxr-xr-x
📄 pango-list	19.11 KB	04/07/2023 10:19:30 AM	rwxr-xr-x
📄 pango-segmentation	19.13 KB	04/07/2023 10:19:30 AM	rwxr-xr-x
📄 pango-view	60.17 KB	04/07/2023 10:19:30 AM	rwxr-xr-x
📄 passenger	1.73 KB	11/23/2025 05:44:26 PM	rwxr-xr-x
📄 passwd	1.02 KB	04/14/2022 02:45:09 PM	rwxr-xr-x
📄 paste	35.58 KB	03/12/2025 12:52:26 PM	rwxr-xr-x
📄 patch	195.02 KB	03/25/2022 03:42:41 PM	rwxr-xr-x
📄 pathchk	35.66 KB	03/12/2025 12:52:26 PM	rwxr-xr-x
📄 pdf2dsc	701 bytes	05/14/2025 04:03:24 PM	rwxr-xr-x
📄 pdf2ps	913 bytes	05/14/2025 04:03:24 PM	rwxr-xr-x
📄 perl	15.13 KB	07/28/2025 03:54:00 AM	rwxr-xr-x
📄 perl5.32.1	15.13 KB	07/28/2025 03:54:00 AM	rwxr-xr-x
📄 perlbug	43.81 KB	07/28/2025 03:54:48 AM	rwxr-xr-x
📄 perldoc	118 bytes	02/14/2022 11:51:30 PM	rwxr-xr-x
📄 perlivp	10.56 KB	07/28/2025 03:53:49 AM	rwxr-xr-x
📄 perlml	14.49 KB	10/02/2025 07:40:19 PM	rwxr-xr-x
📄 perlthanks	43.81 KB	07/28/2025 03:54:48 AM	rwxr-xr-x
📄 pgrep	31.42 KB	04/30/2024 04:43:23 PM	rwxr-xr-x
📄 php	937 bytes	07/01/2025 04:06:13 PM	rwxr-xr-x
📄 pic	201.72 KB	02/01/2022 10:44:53 AM	rwxr-xr-x
📄 piconv	8.08 KB	02/11/2022 04:42:02 PM	rwxr-xr-x
📄 ping	76.51 KB	10/12/2025 12:11:15 AM	rwxr-xr-x
📄 pinky	35.61 KB	03/12/2025 12:52:26 PM	rwxr-xr-x
📄 pkg-config	335 bytes	04/06/2023 08:27:13 PM	rwxr-xr-x
📄 pkill	31.42 KB	04/30/2024 04:43:23 PM	rwxr-xr-x
📄 pl2pm	4.43 KB	07/28/2025 03:54:16 AM	rwxr-xr-x
📄 pmap	35.39 KB	04/30/2024 04:43:23 PM	rwxr-xr-x
📄 pod2html	4.04 KB	07/28/2025 03:54:48 AM	rwxr-xr-x
📄 pod2man	14.68 KB	03/25/2022 12:10:57 PM	rwxr-xr-x
📄 pod2text	10.55 KB	03/25/2022 12:10:57 PM	rwxr-xr-x
📄 pod2usage	4.01 KB	02/11/2022 04:01:30 PM	rwxr-xr-x
📄 podchecker	3.57 KB	02/11/2022 07:01:35 PM	rwxr-xr-x
📄 post-grohtml	199.76 KB	02/01/2022 10:44:53 AM	rwxr-xr-x
📄 pr	72.28 KB	03/12/2025 12:52:26 PM	rwxr-xr-x
📄 pre-grohtml	92.92 KB	02/01/2022 10:44:53 AM	rwxr-xr-x
📄 precat	5.53 KB	10/08/2019 12:15:21 AM	rwxr-xr-x
📄 preunzip	5.53 KB	10/08/2019 12:15:21 AM	rwxr-xr-x
📄 prezip	5.53 KB	10/08/2019 12:15:21 AM	rwxr-xr-x
📄 prezip-bin	15.69 KB	01/26/2022 09:47:25 PM	rwxr-xr-x
📄 printenv	31.47 KB	03/12/2025 12:52:26 PM	rwxr-xr-x
📄 printf	51.77 KB	03/12/2025 12:52:26 PM	rwxr-xr-x
📄 prove	13.24 KB	02/16/2022 11:58:05 AM	rwxr-xr-x
📄 ps	141.15 KB	04/30/2024 04:43:23 PM	rwxr-xr-x
📄 ps2ascii	635 bytes	05/14/2025 04:03:24 PM	rwxr-xr-x
📄 ps2epsi	1.24 KB	05/14/2025 04:03:24 PM	rwxr-xr-x
📄 ps2pdf	276 bytes	05/14/2025 04:03:24 PM	rwxr-xr-x
📄 ps2pdf12	219 bytes	05/14/2025 04:03:24 PM	rwxr-xr-x
📄 ps2pdf13	219 bytes	05/14/2025 04:03:24 PM	rwxr-xr-x
📄 ps2pdf14	219 bytes	05/14/2025 04:03:24 PM	rwxr-xr-x
📄 ps2pdfwr	1.06 KB	05/14/2025 04:03:24 PM	rwxr-xr-x
📄 ps2ps	651 bytes	05/14/2025 04:03:24 PM	rwxr-xr-x
📄 ps2ps2	673 bytes	05/14/2025 04:03:24 PM	rwxr-xr-x
📄 ptx	129.03 KB	03/12/2025 12:52:26 PM	rwxr-xr-x
📄 pwd	35.7 KB	03/12/2025 12:52:26 PM	rwxr-xr-x
📄 pwdx	15.28 KB	04/30/2024 04:43:23 PM	rwxr-xr-x
📄 pydoc	78 bytes	09/02/2025 07:04:27 AM	rwxr-xr-x
📄 pydoc3	78 bytes	09/02/2025 07:04:27 AM	rwxr-xr-x
📄 pydoc3.9	78 bytes	09/02/2025 07:04:27 AM	rwxr-xr-x
📄 ranlib	56 KB	03/31/2025 10:32:51 AM	rwxr-xr-x
📄 readelf	667.28 KB	03/31/2025 10:32:51 AM	rwxr-xr-x
📄 readlink	39.69 KB	03/12/2025 12:52:26 PM	rwxr-xr-x
📄 realpath	39.77 KB	03/12/2025 12:52:26 PM	rwxr-xr-x
📄 recode	31.93 KB	11/02/2022 11:35:06 AM	rwxr-xr-x
📄 red	92 bytes	01/30/2022 05:02:00 AM	rwxr-xr-x
📄 rename	23.41 KB	03/13/2025 06:30:13 AM	rwxr-xr-x
📄 renew-dummy-cert	729 bytes	02/11/2025 09:56:48 PM	rwxr-xr-x
📄 renice	15.36 KB	03/13/2025 06:30:13 AM	rwxr-xr-x
📄 reset	27.34 KB	08/05/2025 09:46:00 AM	rwxr-xr-x
📄 rev	15.35 KB	03/13/2025 06:30:13 AM	rwxr-xr-x
📄 rm	60.21 KB	03/12/2025 12:52:26 PM	rwxr-xr-x
📄 rmdir	43.61 KB	03/12/2025 12:52:26 PM	rwxr-xr-x
📄 rnano	346.2 KB	03/13/2025 03:12:50 AM	rwxr-xr-x
📄 ruby	15.27 KB	05/06/2025 03:53:09 AM	rwxr-xr-x
📄 run-with-aspell	89 bytes	01/26/2022 09:47:11 PM	rwxr-xr-x
📄 runcon	35.65 KB	03/12/2025 12:52:26 PM	rwxr-xr-x
📄 rvi	1.38 MB	10/14/2025 09:11:29 AM	rwxr-xr-x
📄 rview	1.38 MB	10/14/2025 09:11:29 AM	rwxr-xr-x
📄 rvim	3.84 MB	10/14/2025 09:11:29 AM	rwxr-xr-x
📄 scalar	819.34 KB	07/21/2025 04:25:54 PM	rwxr-xr-x
📄 scl	39.55 KB	04/07/2023 01:57:08 AM	rwxr-xr-x
📄 scl_enabled	262 bytes	07/27/2021 03:14:26 PM	rwxr-xr-x
📄 scl_source	1.88 KB	07/27/2021 03:14:26 PM	rwxr-xr-x
📄 scp	133.06 KB	03/13/2025 01:04:20 PM	rwxr-xr-x
📄 screen	484.21 KB	01/04/2022 07:53:04 AM	rwxr-xr-x
📄 script	51.75 KB	03/13/2025 06:30:13 AM	rwxr-xr-x
📄 sdiff	44.2 KB	01/29/2022 06:15:51 PM	rwxr-xr-x
📄 sed	114.01 KB	02/15/2022 10:36:52 AM	rwxr-xr-x
📄 selectorctl	7.63 KB	07/11/2025 03:01:21 PM	rwxr-xr-x
📄 seq	47.79 KB	03/12/2025 12:52:26 PM	rwxr-xr-x
📄 setsid	15.34 KB	03/13/2025 06:30:13 AM	rwxr-xr-x
📄 setterm	35.52 KB	03/13/2025 06:30:13 AM	rwxr-xr-x
📄 sftp	141.05 KB	03/13/2025 01:04:20 PM	rwxr-xr-x
📄 sh	1.32 MB	04/30/2024 02:33:56 PM	rwxr-xr-x
📄 sha1sum	39.64 KB	03/12/2025 12:52:26 PM	rwxr-xr-x
📄 sha224sum	39.64 KB	03/12/2025 12:52:26 PM	rwxr-xr-x
📄 sha256sum	39.64 KB	03/12/2025 12:52:26 PM	rwxr-xr-x
📄 sha384sum	39.64 KB	03/12/2025 12:52:26 PM	rwxr-xr-x
📄 sha512sum	39.64 KB	03/12/2025 12:52:26 PM	rwxr-xr-x
📄 shred	51.88 KB	03/12/2025 12:52:26 PM	rwxr-xr-x
📄 shuf	48.01 KB	03/12/2025 12:52:26 PM	rwxr-xr-x
📄 size	31.61 KB	03/31/2025 10:32:51 AM	rwxr-xr-x
📄 skill	31.4 KB	04/30/2024 04:43:23 PM	rwxr-xr-x
📄 slabtop	23.42 KB	04/30/2024 04:43:23 PM	rwxr-xr-x
📄 sleep	35.65 KB	03/12/2025 12:52:26 PM	rwxr-xr-x
📄 snice	31.4 KB	04/30/2024 04:43:23 PM	rwxr-xr-x
📄 soelim	0 bytes	01/01/1970 12:00:00 AM	---------
📄 sort	113.09 KB	03/12/2025 12:52:26 PM	rwxr-xr-x
📄 spell	125 bytes	10/08/2019 12:15:21 AM	rwxr-xr-x
📄 splain	18.96 KB	07/28/2025 03:54:48 AM	rwxr-xr-x
📄 split	52.31 KB	03/12/2025 12:52:26 PM	rwxr-xr-x
📄 sprof	35.45 KB	11/05/2025 09:33:47 AM	rwxr-xr-x
📄 sqlite3	1.52 MB	07/28/2025 09:55:38 PM	rwxr-xr-x
📄 ssh	843.53 KB	03/13/2025 01:04:20 PM	rwxr-xr-x
📄 ssh-add	164.86 KB	03/13/2025 01:04:20 PM	rwxr-xr-x
📄 ssh-agent	281.02 KB	03/13/2025 01:04:20 PM	rwxr-xr-x
📄 ssh-copy-id	12.38 KB	03/13/2025 01:04:18 PM	rwxr-xr-x
📄 ssh-keygen	455.04 KB	03/13/2025 01:04:20 PM	rwxr-xr-x
📄 ssh-keyscan	197.43 KB	03/13/2025 01:04:20 PM	rwxr-xr-x
📄 stat	80.06 KB	03/12/2025 12:52:26 PM	rwxr-xr-x
📄 stdbuf	43.74 KB	03/12/2025 12:52:26 PM	rwxr-xr-x
📄 strace	2.08 MB	03/12/2025 07:11:27 PM	rwxr-xr-x
📄 stream	15.27 KB	04/01/2025 12:55:20 PM	rwxr-xr-x
📄 strings	31.74 KB	03/31/2025 10:32:51 AM	rwxr-xr-x
📄 strip	185.36 KB	03/31/2025 10:32:51 AM	rwxr-xr-x
📄 stty	75.83 KB	03/12/2025 12:52:26 PM	rwxr-xr-x
📄 sum	35.59 KB	03/12/2025 12:52:26 PM	rwxr-xr-x
📄 sync	35.54 KB	03/12/2025 12:52:26 PM	rwxr-xr-x
📄 tabs	19.16 KB	08/05/2025 09:46:00 AM	rwxr-xr-x
📄 tac	104.6 KB	03/12/2025 12:52:26 PM	rwxr-xr-x
📄 tail	68.09 KB	03/12/2025 12:52:26 PM	rwxr-xr-x
📄 tar	514.27 KB	10/02/2024 09:24:00 PM	rwxr-xr-x
📄 taskset	23.41 KB	03/13/2025 06:30:13 AM	rwxr-xr-x
📄 tbl	130.86 KB	02/01/2022 10:44:53 AM	rwxr-xr-x
📄 tclsh	15.69 KB	10/15/2022 09:29:43 PM	rwxr-xr-x
📄 tclsh8.6	15.69 KB	10/15/2022 09:29:43 PM	rwxr-xr-x
📄 tee	35.69 KB	03/12/2025 12:52:26 PM	rwxr-xr-x
📄 test	43.79 KB	03/12/2025 12:52:26 PM	rwxr-xr-x
📄 tic	87.8 KB	08/05/2025 09:46:00 AM	rwxr-xr-x
📄 timeout	40.17 KB	03/12/2025 12:52:26 PM	rwxr-xr-x
📄 tload	19.34 KB	04/30/2024 04:43:23 PM	rwxr-xr-x
📄 tmpwatch	36.03 KB	02/11/2022 11:52:55 AM	rwxr-xr-x
📄 toe	23.23 KB	08/05/2025 09:46:00 AM	rwxr-xr-x
📄 top	132.27 KB	04/30/2024 04:43:23 PM	rwxr-xr-x
📄 touch	92.03 KB	03/12/2025 12:52:26 PM	rwxr-xr-x
📄 tput	27.25 KB	08/05/2025 09:46:00 AM	rwxr-xr-x
📄 tr	47.87 KB	03/12/2025 12:52:26 PM	rwxr-xr-x
📄 troff	732.07 KB	02/01/2022 10:44:53 AM	rwxr-xr-x
📄 true	27.47 KB	03/12/2025 12:52:26 PM	rwxr-xr-x
📄 truncate	35.66 KB	03/12/2025 12:52:26 PM	rwxr-xr-x
📄 tset	27.34 KB	08/05/2025 09:46:00 AM	rwxr-xr-x
📄 tsort	47.79 KB	03/12/2025 12:52:26 PM	rwxr-xr-x
📄 tty	31.65 KB	03/12/2025 12:52:26 PM	rwxr-xr-x
📄 tzselect	14.99 KB	11/05/2025 09:30:56 AM	rwxr-xr-x
📄 uapi	1.02 KB	03/14/2026 09:26:07 AM	rwxr-xr-x
📄 ul	23.45 KB	03/13/2025 06:30:13 AM	rwxr-xr-x
📄 uname	31.66 KB	03/12/2025 12:52:26 PM	rwxr-xr-x
📄 unexpand	39.73 KB	03/12/2025 12:52:26 PM	rwxr-xr-x
📄 uniq	43.83 KB	03/12/2025 12:52:26 PM	rwxr-xr-x
📄 unlink	31.66 KB	03/12/2025 12:52:26 PM	rwxr-xr-x
📄 unzip	196.14 KB	03/18/2025 03:53:48 AM	rwxr-xr-x
📄 unzipsfx	87.89 KB	03/18/2025 03:53:48 AM	rwxr-xr-x
📄 uptime	15.29 KB	04/30/2024 04:43:23 PM	rwxr-xr-x
📄 users	35.68 KB	03/12/2025 12:52:26 PM	rwxr-xr-x
📄 utmpdump	23.4 KB	03/13/2025 06:30:13 AM	rwxr-xr-x
📄 vdir	137.65 KB	03/12/2025 12:52:26 PM	rwxr-xr-x
📄 vi	691 bytes	10/14/2025 09:11:26 AM	rwxr-xr-x
📄 view	150 bytes	10/14/2025 09:11:26 AM	rwxr-xr-x
📄 vim	3.84 MB	10/14/2025 09:11:29 AM	rwxr-xr-x
📄 vimdiff	3.84 MB	10/14/2025 09:11:29 AM	rwxr-xr-x
📄 vimtutor	2.07 KB	10/14/2025 09:11:25 AM	rwxr-xr-x
📄 vmstat	39.41 KB	04/30/2024 04:43:23 PM	rwxr-xr-x
📄 watch	27.87 KB	04/30/2024 04:43:23 PM	rwxr-xr-x
📄 wc	43.73 KB	03/12/2025 12:52:26 PM	rwxr-xr-x
📄 wget	521.41 KB	09/03/2024 11:58:56 AM	rwxr-xr-x
📄 whereis	32.03 KB	03/13/2025 06:30:13 AM	rwxr-xr-x
📄 which	27.89 KB	08/05/2025 06:19:33 AM	rwxr-xr-x
📄 who	51.77 KB	03/12/2025 12:52:26 PM	rwxr-xr-x
📄 whoami	31.66 KB	03/12/2025 12:52:26 PM	rwxr-xr-x
📄 word-list-compress	15.7 KB	01/26/2022 09:47:25 PM	rwxr-xr-x
📄 x86_64-redhat-linux-c++	1.04 MB	02/12/2025 01:11:11 PM	rwxr-xr-x
📄 x86_64-redhat-linux-g++	1.04 MB	02/12/2025 01:11:11 PM	rwxr-xr-x
📄 x86_64-redhat-linux-gcc	1.04 MB	02/12/2025 01:11:11 PM	rwxr-xr-x
📄 x86_64-redhat-linux-gcc-11	1.04 MB	02/12/2025 01:11:11 PM	rwxr-xr-x
📄 xargs	64.09 KB	10/02/2024 09:04:59 PM	rwxr-xr-x
📄 xmlcatalog	23.15 KB	08/07/2025 03:49:23 PM	rwxr-xr-x
📄 xmllint	80.55 KB	08/07/2025 03:49:23 PM	rwxr-xr-x
📄 xmlwf	39.63 KB	05/13/2025 05:53:46 PM	rwxr-xr-x
📄 xsltproc	31.23 KB	05/13/2025 07:06:03 PM	rwxr-xr-x
📄 xsubpp	4.96 KB	02/16/2022 08:56:48 AM	rwxr-xr-x
📄 xxd	19.32 KB	10/14/2025 09:11:29 AM	rwxr-xr-x
📄 yes	31.51 KB	03/12/2025 12:52:26 PM	rwxr-xr-x
📄 zcat	1.94 KB	10/15/2022 05:26:34 PM	rwxr-xr-x
📄 zcmp	1.64 KB	10/15/2022 05:26:34 PM	rwxr-xr-x
📄 zdiff	6.31 KB	10/15/2022 05:26:34 PM	rwxr-xr-x
📄 zegrep	33 bytes	10/15/2022 05:26:34 PM	rwxr-xr-x
📄 zfgrep	33 bytes	10/15/2022 05:26:34 PM	rwxr-xr-x
📄 zforce	2.04 KB	10/15/2022 05:26:34 PM	rwxr-xr-x
📄 zgrep	7.93 KB	10/15/2022 05:26:34 PM	rwxr-xr-x
📄 zip	221.09 KB	04/07/2023 02:02:33 PM	rwxr-xr-x
📄 zipcloak	75.7 KB	04/07/2023 02:02:33 PM	rwxr-xr-x
📄 zipgrep	2.89 KB	10/10/2008 05:40:36 PM	rwxr-xr-x
📄 zipinfo	196.14 KB	03/18/2025 03:53:48 AM	rwxr-xr-x
📄 zipnote	67.61 KB	04/07/2023 02:02:33 PM	rwxr-xr-x
📄 zipsplit	63.58 KB	04/07/2023 02:02:33 PM	rwxr-xr-x
📄 zless	2.16 KB	10/15/2022 05:26:34 PM	rwxr-xr-x
📄 zmore	1.8 KB	10/15/2022 05:26:34 PM	rwxr-xr-x
📄 znew	4.47 KB	10/15/2022 05:26:34 PM	rwxr-xr-x
📄 zsoelim	0 bytes	01/01/1970 12:00:00 AM	---------

Editing: enc2xs

#!/usr/bin/perl
BEGIN {
    # @INC poking  no longer needed w/ new MakeMaker and Makefile.PL's
    # with $ENV{PERL_CORE} set
    # In case we need it in future...
    require Config; import Config;
    pop @INC if $INC[-1] eq '.';
}
use strict;
use warnings;
use Getopt::Std;
use Config;
my @orig_ARGV = @ARGV;
our $VERSION  = do { my @r = (q$Revision: 2.23 $ =~ /\d+/g); sprintf "%d."."%02d" x $#r, @r };

# These may get re-ordered.
# RAW is a do_now as inserted by &enter
# AGG is an aggregated do_now, as built up by &process

use constant {
  RAW_NEXT => 0,
  RAW_IN_LEN => 1,
  RAW_OUT_BYTES => 2,
  RAW_FALLBACK => 3,

AGG_MIN_IN => 0,
  AGG_MAX_IN => 1,
  AGG_OUT_BYTES => 2,
  AGG_NEXT => 3,
  AGG_IN_LEN => 4,
  AGG_OUT_LEN => 5,
  AGG_FALLBACK => 6,
};

# (See the algorithm in encengine.c - we're building structures for it)

# There are two sorts of structures.
# "do_now" (an array, two variants of what needs storing) is whatever we need
# to do now we've read an input byte.
# It's housed in a "do_next" (which is how we got to it), and in turn points
# to a "do_next" which contains all the "do_now"s for the next input byte.

# There will be a "do_next" which is the start state.
# For a single byte encoding it's the only "do_next" - each "do_now" points
# back to it, and each "do_now" will cause bytes. There is no state.

# For a multi-byte encoding where all characters in the input are the same
# length, then there will be a tree of "do_now"->"do_next"->"do_now"
# branching out from the start state, one step for each input byte.
# The leaf "do_now"s will all be at the same distance from the start state,
# only the leaf "do_now"s cause output bytes, and they in turn point back to
# the start state.

# For an encoding where there are variable length input byte sequences, you
# will encounter a leaf "do_now" sooner for the shorter input sequences, but
# as before the leaves will point back to the start state.

# The system will cope with escape encodings (imagine them as a mostly
# self-contained tree for each escape state, and cross links between trees
# at the state-switching characters) but so far no input format defines these.

# The system will also cope with having output "leaves" in the middle of
# the bifurcating branches, not just at the extremities, but again no
# input format does this yet.

# There are two variants of the "do_now" structure. The first, smaller variant
# is generated by &enter as the input file is read. There is one structure
# for each input byte. Say we are mapping a single byte encoding to a
# single byte encoding, with  "ABCD" going "abcd". There will be
# 4 "do_now"s, {"A" => [...,"a",...], "B" => [...,"b",...], "C"=>..., "D"=>...}

# &process then walks the tree, building aggregate "do_now" structures for
# adjacent bytes where possible. The aggregate is for a contiguous range of
# bytes which each produce the same length of output, each move to the
# same next state, and each have the same fallback flag.
# So our 4 RAW "do_now"s above become replaced by a single structure
# containing:
# ["A", "D", "abcd", 1, ...]
# ie, for an input byte $_ in "A".."D", output 1 byte, found as
# substr ("abcd", (ord $_ - ord "A") * 1, 1)
# which maps very nicely into pointer arithmetic in C for encengine.c

sub encode_U
{
 # UTF-8 encode long hand - only covers part of perl's range
 ## my $uv = shift;
 # chr() works in native space so convert value from table
 # into that space before using chr().
 my $ch = chr(utf8::unicode_to_native($_[0]));
 # Now get core perl to encode that the way it likes.
 utf8::encode($ch);
 return $ch;
}

sub encode_S
{
 # encode single byte
 ## my ($ch,$page) = @_; return chr($ch);
 return chr $_[0];
}

sub encode_D
{
 # encode double byte MS byte first
 ## my ($ch,$page) = @_; return chr($page).chr($ch);
 return chr ($_[1]) . chr $_[0];
}

sub encode_M
{
 # encode Multi-byte - single for 0..255 otherwise double
 ## my ($ch,$page) = @_;
 ## return &encode_D if $page;
 ## return &encode_S;
 return chr ($_[1]) . chr $_[0] if $_[1];
 return chr $_[0];
}

my %encode_types = (U => \&encode_U,
                    S => \&encode_S,
                    D => \&encode_D,
                    M => \&encode_M,
                   );

# Win32 does not expand globs on command line
if ($^O eq 'MSWin32' and !$ENV{PERL_CORE}) {
    eval "\@ARGV = map(glob(\$_),\@ARGV)";
    @ARGV = @orig_ARGV unless @ARGV;
}

my %opt;
# I think these are:
# -Q to disable the duplicate codepoint test
# -S make mapping errors fatal
# -q to remove comments written to output files
# -O to enable the (brute force) substring optimiser
# -o <output> to specify the output file name (else it's the first arg)
# -f <inlist> to give a file with a list of input files (else use the args)
# -n <name> to name the encoding (else use the basename of the input file.
#Getopt::Long::Configure("bundling");
#GetOptions(\%opt, qw(C M=s S Q q O o=s f=s n=s v));
getopts('CM:SQqOo:f:n:v',\%opt);

$opt{M} and make_makefile_pl($opt{M}, @ARGV);
$opt{C} and make_configlocal_pm($opt{C}, @ARGV);
$opt{v} ||= $ENV{ENC2XS_VERBOSE};
$opt{q} ||= $ENV{ENC2XS_NO_COMMENTS};

sub verbose {
    print STDERR @_ if $opt{v};
}
sub verbosef {
    printf STDERR @_ if $opt{v};
}

# ($cpp, $static, $sized) = compiler_info($declaration)
#
# return some information about the compiler and compile options we're using:
#
#   $declaration - true if we're doing a declaration rather than a definition.
#
#   $cpp    - we're using C++
#   $static - ok to declare the arrays as static
#   $sized  - the array declarations should be sized

sub compiler_info {
    my ($declaration) = @_;

my $ccflags = $Config{ccflags};
    if (defined $Config{ccwarnflags}) {
        $ccflags .= " " . $Config{ccwarnflags};
    }
    my $compat   = $ccflags =~ /\Q-Wc++-compat/;
    my $pedantic = $ccflags =~ /-pedantic/;

my $cpp      = ($Config{d_cplusplus} || '') eq 'define';

# The encpage_t tables contain recursive and mutually recursive
    # references. To allow them to compile under C++ and some restrictive
    # cc options, it may be necessary to make the tables non-static/const
    # (thus moving them from the text to the data segment) and/or not
    # include the size in the declaration.

my $static = !(
                        $cpp
                     || ($compat && $pedantic)
                     || ($^O eq 'MacOS' && $declaration)
                  );

# -Wc++-compat on its own warns if the array declaration is sized.
    # The easiest way to avoid this warning is simply not to include
    # the size in the declaration.
    # With -pedantic as well, the issue doesn't arise because $static
    # above becomes false.
    my $sized  = $declaration && !($compat && !$pedantic);

return ($cpp, $static, $sized);
}

# This really should go first, else the die here causes empty (non-erroneous)
# output files to be written.
my @encfiles;
if (exists $opt{f}) {
    # -F is followed by name of file containing list of filenames
    my $flist = $opt{f};
    open(FLIST,$flist) || die "Cannot open $flist:$!";
    chomp(@encfiles = <FLIST>);
    close(FLIST);
} else {
    @encfiles = @ARGV;
}

my $cname = $opt{o} ? $opt{o} : shift(@ARGV);
unless ($cname) { #debuging a win32 nmake error-only. works via cmdline
    print "\nARGV:";
    print "$_ " for @ARGV;
    print "\nopt:";
    print "  $_ => ",defined $opt{$_}?$opt{$_}:"undef","\n" for keys %opt;
}
chmod(0666,$cname) if -f $cname && !-w $cname;
open(C,">", $cname) || die "Cannot open $cname:$!";

my $dname = $cname;
my $hname = $cname;

my ($doC,$doEnc,$doUcm,$doPet);

if ($cname =~ /\.(c|xs)$/i) # VMS may have upcased filenames with DECC$ARGV_PARSE_STYLE defined
 {
  $doC = 1;
  $dname =~ s/(\.[^\.]*)?$/.exh/;
  chmod(0666,$dname) if -f $cname && !-w $dname;
  open(D,">", $dname) || die "Cannot open $dname:$!";
  $hname =~ s/(\.[^\.]*)?$/.h/;
  chmod(0666,$hname) if -f $cname && !-w $hname;
  open(H,">", $hname) || die "Cannot open $hname:$!";

foreach my $fh (\*C,\*D,\*H)
  {
   print $fh <<"END" unless $opt{'q'};
/*
 !!!!!!!   DO NOT EDIT THIS FILE   !!!!!!!
 This file was autogenerated by:
 $^X $0 @orig_ARGV
 enc2xs VERSION $VERSION
*/
END
  }

if ($cname =~ /(\w+)\.xs$/)
   {
    print C "#define PERL_NO_GET_CONTEXT\n";
    print C "#include <EXTERN.h>\n";
    print C "#include <perl.h>\n";
    print C "#include <XSUB.h>\n";
   }
  print C "#include \"encode.h\"\n\n";

}
elsif ($cname =~ /\.enc$/)
 {
  $doEnc = 1;
 }
elsif ($cname =~ /\.ucm$/)
 {
  $doUcm = 1;
 }
elsif ($cname =~ /\.pet$/)
 {
  $doPet = 1;
 }

my %encoding;
my %strings;
my $string_acc;
my %strings_in_acc;

my $saved = 0;
my $subsave = 0;
my $strings = 0;

sub cmp_name
{
 if ($a =~ /^.*-(\d+)/)
  {
   my $an = $1;
   if ($b =~ /^.*-(\d+)/)
    {
     my $r = $an <=> $1;
     return $r if $r;
    }
  }
 return $a cmp $b;
}

foreach my $enc (sort cmp_name @encfiles)
 {
  my ($name,$sfx) = $enc =~ /^.*?([\w-]+)\.(enc|ucm)$/;
  $name = $opt{'n'} if exists $opt{'n'};
  if (open(E,$enc))
   {
    if ($sfx eq 'enc')
     {
      compile_enc(\*E,lc($name));
     }
    else
     {
      compile_ucm(\*E,lc($name));
     }
   }
  else
   {
    warn "Cannot open $enc for $name:$!";
   }
 }

if ($doC)
 {
  verbose "Writing compiled form\n";
  foreach my $name (sort cmp_name keys %encoding)
   {
    my ($e2u,$u2e,$erep,$min_el,$max_el) = @{$encoding{$name}};
    process($name.'_utf8',$e2u);
    addstrings(\*C,$e2u);

process('utf8_'.$name,$u2e);
    addstrings(\*C,$u2e);
   }
  outbigstring(\*C,"enctable");
  foreach my $name (sort cmp_name keys %encoding)
   {
    my ($e2u,$u2e,$erep,$min_el,$max_el) = @{$encoding{$name}};
    outtable(\*C,$e2u, "enctable");
    outtable(\*C,$u2e, "enctable");

# push(@{$encoding{$name}},outstring(\*C,$e2u->{Cname}.'_def',$erep));
   }
  my ($cpp) = compiler_info(0);
  my $ext  = $cpp ? 'extern "C"' : "extern";
  my $exta = $cpp ? 'extern "C"' : "static";
  my $extb = $cpp ? 'extern "C"' : "";
  foreach my $enc (sort cmp_name keys %encoding)
   {
    # my ($e2u,$u2e,$rep,$min_el,$max_el,$rsym) = @{$encoding{$enc}};
    my ($e2u,$u2e,$rep,$min_el,$max_el) = @{$encoding{$enc}};
    #my @info = ($e2u->{Cname},$u2e->{Cname},$rsym,length($rep),$min_el,$max_el);
    my $replen = 0; 
    $replen++ while($rep =~ /\G\\x[0-9A-Fa-f]/g);
    my $sym = "${enc}_encoding";
    $sym =~ s/\W+/_/g;
    my @info = ($e2u->{Cname},$u2e->{Cname},"${sym}_rep_character",$replen,
        $min_el,$max_el);
    print C "${exta} const U8 ${sym}_rep_character[] = \"$rep\";\n";
    print C "${exta} const char ${sym}_enc_name[] = \"$enc\";\n\n";
    print C "${extb} const encode_t $sym = \n";
    # This is to make null encoding work -- dankogai
    for (my $i = (scalar @info) - 1;  $i >= 0; --$i){
    $info[$i] ||= 1;
    }
    # end of null tweak -- dankogai
    print C " {",join(',',@info,"{${sym}_enc_name,(const char *)0}"),"};\n\n";
   }

foreach my $enc (sort cmp_name keys %encoding)
   {
    my $sym = "${enc}_encoding";
    $sym =~ s/\W+/_/g;
    print H "${ext} encode_t $sym;\n";
    print D " Encode_XSEncoding(aTHX_ &$sym);\n";
   }

if ($cname =~ /(\w+)\.xs$/)
   {
    my $mod = $1;
    print C <<'END';

static void
Encode_XSEncoding(pTHX_ encode_t *enc)
{
 dSP;
 HV *stash = gv_stashpv("Encode::XS", TRUE);
 SV *iv    = newSViv(PTR2IV(enc));
 SV *sv    = sv_bless(newRV_noinc(iv),stash);
 int i = 0;
 /* with the SvLEN() == 0 hack, PVX won't be freed. We cast away name's
 constness, in the hope that perl won't mess with it. */
 assert(SvTYPE(iv) >= SVt_PV); assert(SvLEN(iv) == 0);
 SvFLAGS(iv) |= SVp_POK;
 SvPVX(iv) = (char*) enc->name[0];
 PUSHMARK(sp);
 XPUSHs(sv);
 while (enc->name[i])
  {
   const char *name = enc->name[i++];
   XPUSHs(sv_2mortal(newSVpvn(name,strlen(name))));
  }
 PUTBACK;
 call_pv("Encode::define_encoding",G_DISCARD);
 SvREFCNT_dec(sv);
}

END

print C "\nMODULE = Encode::$mod\tPACKAGE = Encode::$mod\n\n";
    print C "BOOT:\n{\n";
    print C "#include \"$dname\"\n";
    print C "}\n";
   }
  # Close in void context is bad, m'kay
  close(D) or warn "Error closing '$dname': $!";
  close(H) or warn "Error closing '$hname': $!";

my $perc_saved    = $saved/($strings + $saved) * 100;
  my $perc_subsaved = $subsave/($strings + $subsave) * 100;
  verbosef "%d bytes in string tables\n",$strings;
  verbosef "%d bytes (%.3g%%) saved spotting duplicates\n",
    $saved, $perc_saved              if $saved;
  verbosef "%d bytes (%.3g%%) saved using substrings\n",
    $subsave, $perc_subsaved         if $subsave;
 }
elsif ($doEnc)
 {
  foreach my $name (sort cmp_name keys %encoding)
   {
    my ($e2u,$u2e,$erep,$min_el,$max_el) = @{$encoding{$name}};
    output_enc(\*C,$name,$e2u);
   }
 }
elsif ($doUcm)
 {
  foreach my $name (sort cmp_name keys %encoding)
   {
    my ($e2u,$u2e,$erep,$min_el,$max_el) = @{$encoding{$name}};
    output_ucm(\*C,$name,$u2e,$erep,$min_el,$max_el);
   }
 }

# writing half meg files and then not checking to see if you just filled the
# disk is bad, m'kay
close(C) or die "Error closing '$cname': $!";

# End of the main program.

sub compile_ucm
{
 my ($fh,$name) = @_;
 my $e2u = {};
 my $u2e = {};
 my $cs;
 my %attr;
 while (<$fh>)
  {
   s/#.*$//;
   last if /^\s*CHARMAP\s*$/i;
   if (/^\s*<(\w+)>\s+"?([^"]*)"?\s*$/i) # " # Grrr
    {
     $attr{$1} = $2;
    }
  }
 if (!defined($cs =  $attr{'code_set_name'}))
  {
   warn "No <code_set_name> in $name\n";
  }
 else
  {
   $name = $cs unless exists $opt{'n'};
  }
 my $erep;
 my $urep;
 my $max_el;
 my $min_el;
 if (exists $attr{'subchar'})
  {
   #my @byte;
   #$attr{'subchar'} =~ /^\s*/cg;
   #push(@byte,$1) while $attr{'subchar'} =~ /\G\\x([0-9a-f]+)/icg;
   #$erep = join('',map(chr(hex($_)),@byte));
   $erep = $attr{'subchar'}; 
   $erep =~ s/^\s+//; $erep =~ s/\s+$//;
  }
 print "Reading $name ($cs)\n"
   unless defined $ENV{MAKEFLAGS}
      and $ENV{MAKEFLAGS} =~ /\b(s|silent|quiet)\b/;
 my $nfb = 0;
 my $hfb = 0;
 while (<$fh>)
  {
   s/#.*$//;
   last if /^\s*END\s+CHARMAP\s*$/i;
   next if /^\s*$/;
   my (@uni, @byte) = ();
   my ($uni, $byte, $fb) = m/^(\S+)\s+(\S+)\s+(\S+)\s+/o
       or die "Bad line: $_";
   while ($uni =~  m/\G<([U0-9a-fA-F\+]+)>/g){
       push @uni, map { substr($_, 1) } split(/\+/, $1);
   }
   while ($byte =~ m/\G\\x([0-9a-fA-F]+)/g){
       push @byte, $1;
   }
   if (@uni)
    {
     my $uch =  join('', map { encode_U(hex($_)) } @uni );
     my $ech = join('',map(chr(hex($_)),@byte));
     my $el  = length($ech);
     $max_el = $el if (!defined($max_el) || $el > $max_el);
     $min_el = $el if (!defined($min_el) || $el < $min_el);
     if (length($fb))
      {
       $fb = substr($fb,1);
       $hfb++;
      }
     else
      {
       $nfb++;
       $fb = '0';
      }
     # $fb is fallback flag
     # 0 - round trip safe
     # 1 - fallback for unicode -> enc
     # 2 - skip sub-char mapping
     # 3 - fallback enc -> unicode
     enter($u2e,$uch,$ech,$u2e,$fb+0) if ($fb =~ /[01]/);
     enter($e2u,$ech,$uch,$e2u,$fb+0) if ($fb =~ /[03]/);
    }
   else
    {
     warn $_;
    }
  }
 if ($nfb && $hfb)
  {
   die "$nfb entries without fallback, $hfb entries with\n";
  }
 $encoding{$name} = [$e2u,$u2e,$erep,$min_el,$max_el];
}

sub compile_enc
{
 my ($fh,$name) = @_;
 my $e2u = {};
 my $u2e = {};

my $type;
 while ($type = <$fh>)
  {
   last if $type !~ /^\s*#/;
  }
 chomp($type);
 return if $type eq 'E';
 # Do the hash lookup once, rather than once per function call. 4% speedup.
 my $type_func = $encode_types{$type};
 my ($def,$sym,$pages) = split(/\s+/,scalar(<$fh>));
 warn "$type encoded $name\n";
 my $rep = '';
 # Save a defined test by setting these to defined values.
 my $min_el = ~0; # A very big integer
 my $max_el = 0;  # Anything must be longer than 0
 {
  my $v = hex($def);
  $rep = &$type_func($v & 0xFF, ($v >> 8) & 0xffe);
 }
 my $errors;
 my $seen;
 # use -Q to silence the seen test. Makefile.PL uses this by default.
 $seen = {} unless $opt{Q};
 do
  {
   my $line = <$fh>;
   chomp($line);
   my $page = hex($line);
   my $ch = 0;
   my $i = 16;
   do
    {
     # So why is it 1% faster to leave the my here?
     my $line = <$fh>;
     $line =~ s/\r\n$/\n/;
     die "$.:${line}Line should be exactly 65 characters long including
     newline (".length($line).")" unless length ($line) == 65;
     # Split line into groups of 4 hex digits, convert groups to ints
     # This takes 65.35		
     # map {hex $_} $line =~ /(....)/g
     # This takes 63.75 (2.5% less time)
     # unpack "n*", pack "H*", $line
     # There's an implicit loop in map. Loops are bad, m'kay. Ops are bad, m'kay
     # Doing it as while ($line =~ /(....)/g) took 74.63
     foreach my $val (unpack "n*", pack "H*", $line)
      {
       next if $val == 0xFFFD;
       my $ech = &$type_func($ch,$page);
       if ($val || (!$ch && !$page))
        {
         my $el  = length($ech);
         $max_el = $el if $el > $max_el;
         $min_el = $el if $el < $min_el;
         my $uch = encode_U($val);
         if ($seen) {
           # We're doing the test.
           # We don't need to read this quickly, so storing it as a scalar,
           # rather than 3 (anon array, plus the 2 scalars it holds) saves
           # RAM and may make us faster on low RAM systems. [see __END__]
           if (exists $seen->{$uch})
             {
               warn sprintf("U%04X is %02X%02X and %04X\n",
                            $val,$page,$ch,$seen->{$uch});
               $errors++;
             }
           else
             {
               $seen->{$uch} = $page << 8 | $ch;
             }
         }
         # Passing 2 extra args each time is 3.6% slower!
         # Even with having to add $fallback ||= 0 later
         enter_fb0($e2u,$ech,$uch);
         enter_fb0($u2e,$uch,$ech);
        }
       else
        {
         # No character at this position
         # enter($e2u,$ech,undef,$e2u);
        }
       $ch++;
      }
    } while --$i;
  } while --$pages;
 die "\$min_el=$min_el, \$max_el=$max_el - seems we read no lines"
   if $min_el > $max_el;
 die "$errors mapping conflicts\n" if ($errors && $opt{'S'});
 $encoding{$name} = [$e2u,$u2e,$rep,$min_el,$max_el];
}

# my ($a,$s,$d,$t,$fb) = @_;
sub enter {
  my ($current,$inbytes,$outbytes,$next,$fallback) = @_;
  # state we shift to after this (multibyte) input character defaults to same
  # as current state.
  $next ||= $current;
  # Making sure it is defined seems to be faster than {no warnings;} in
  # &process, or passing it in as 0 explicitly.
  # XXX $fallback ||= 0;

# Start at the beginning and work forwards through the string to zero.
  # effectively we are removing 1 character from the front each time
  # but we don't actually edit the string. [this alone seems to be 14% speedup]
  # Hence -$pos is the length of the remaining string.
  my $pos = -length $inbytes;
  while (1) {
    my $byte = substr $inbytes, $pos, 1;
    #  RAW_NEXT => 0,
    #  RAW_IN_LEN => 1,
    #  RAW_OUT_BYTES => 2,
    #  RAW_FALLBACK => 3,
    # to unicode an array would seem to be better, because the pages are dense.
    # from unicode can be very sparse, favouring a hash.
    # hash using the bytes (all length 1) as keys rather than ord value,
    # as it's easier to sort these in &process.

# It's faster to always add $fallback even if it's undef, rather than
    # choosing between 3 and 4 element array. (hence why we set it defined
    # above)
    my $do_now = $current->{Raw}{$byte} ||= [{},-$pos,'',$fallback];
    # When $pos was -1 we were at the last input character.
    unless (++$pos) {
      $do_now->[RAW_OUT_BYTES] = $outbytes;
      $do_now->[RAW_NEXT] = $next;
      return;
    }
    # Tail recursion. The intermediate state may not have a name yet.
    $current = $do_now->[RAW_NEXT];
  }
}

# This is purely for optimisation. It's just &enter hard coded for $fallback
# of 0, using only a 3 entry array ref to save memory for every entry.
sub enter_fb0 {
  my ($current,$inbytes,$outbytes,$next) = @_;
  $next ||= $current;

my $pos = -length $inbytes;
  while (1) {
    my $byte = substr $inbytes, $pos, 1;
    my $do_now = $current->{Raw}{$byte} ||= [{},-$pos,''];
    unless (++$pos) {
      $do_now->[RAW_OUT_BYTES] = $outbytes;
      $do_now->[RAW_NEXT] = $next;
      return;
    }
    $current = $do_now->[RAW_NEXT];
  }
}

sub process
{
  my ($name,$a) = @_;
  $name =~ s/\W+/_/g;
  $a->{Cname} = $name;
  my $raw = $a->{Raw};
  my ($l, $agg_max_in, $agg_next, $agg_in_len, $agg_out_len, $agg_fallback);
  my @ent;
  $agg_max_in = 0;
  foreach my $key (sort keys %$raw) {
    #  RAW_NEXT => 0,
    #  RAW_IN_LEN => 1,
    #  RAW_OUT_BYTES => 2,
    #  RAW_FALLBACK => 3,
    my ($next, $in_len, $out_bytes, $fallback) = @{$raw->{$key}};
    # Now we are converting from raw to aggregate, switch from 1 byte strings
    # to numbers
    my $b = ord $key;
    $fallback ||= 0;
    if ($l &&
        # If this == fails, we're going to reset $agg_max_in below anyway.
        $b == ++$agg_max_in &&
        # References in numeric context give the pointer as an int.
        $agg_next == $next &&
        $agg_in_len == $in_len &&
        $agg_out_len == length $out_bytes &&
        $agg_fallback == $fallback
        # && length($l->[AGG_OUT_BYTES]) < 16
       ) {
      #     my $i = ord($b)-ord($l->[AGG_MIN_IN]);
      # we can aggregate this byte onto the end.
      $l->[AGG_MAX_IN] = $b;
      $l->[AGG_OUT_BYTES] .= $out_bytes;
    } else {
      # AGG_MIN_IN => 0,
      # AGG_MAX_IN => 1,
      # AGG_OUT_BYTES => 2,
      # AGG_NEXT => 3,
      # AGG_IN_LEN => 4,
      # AGG_OUT_LEN => 5,
      # AGG_FALLBACK => 6,
      # Reset the last thing we saw, plus set 5 lexicals to save some derefs.
      # (only gains .6% on euc-jp  -- is it worth it?)
      push @ent, $l = [$b, $agg_max_in = $b, $out_bytes, $agg_next = $next,
                       $agg_in_len = $in_len, $agg_out_len = length $out_bytes,
                       $agg_fallback = $fallback];
    }
    if (exists $next->{Cname}) {
      $next->{'Forward'} = 1 if $next != $a;
    } else {
      process(sprintf("%s_%02x",$name,$b),$next);
    }
  }
  # encengine.c rules say that last entry must be for 255
  if ($agg_max_in < 255) {
    push @ent, [1+$agg_max_in, 255,undef,$a,0,0];
  }
  $a->{'Entries'} = \@ent;
}

sub addstrings
{
 my ($fh,$a) = @_;
 my $name = $a->{'Cname'};
 # String tables
 foreach my $b (@{$a->{'Entries'}})
  {
   next unless $b->[AGG_OUT_LEN];
   $strings{$b->[AGG_OUT_BYTES]} = undef;
  }
 if ($a->{'Forward'})
  {
   my ($cpp, $static, $sized) = compiler_info(1);
   my $count = $sized ? scalar(@{$a->{'Entries'}}) : '';
   if ($static) {
     # we cannot ask Config for d_plusplus since we can override CC=g++-6 on the cmdline
     print $fh "#ifdef __cplusplus\n"; # -fpermissive since g++-6
     print $fh "extern encpage_t $name\[$count];\n";
     print $fh "#else\n";
     print $fh "static const encpage_t $name\[$count];\n";
     print $fh "#endif\n";
   } else {
     print $fh "extern encpage_t $name\[$count];\n";
   }
  }
 $a->{'DoneStrings'} = 1;
 foreach my $b (@{$a->{'Entries'}})
  {
   my ($s,$e,$out,$t,$end,$l) = @$b;
   addstrings($fh,$t) unless $t->{'DoneStrings'};
  }
}

sub outbigstring
{
  my ($fh,$name) = @_;

$string_acc = '';

# Make the big string in the string accumulator. Longest first, on the hope
  # that this makes it more likely that we find the short strings later on.
  # Not sure if it helps sorting strings of the same length lexically.
  foreach my $s (sort {length $b <=> length $a || $a cmp $b} keys %strings) {
    my $index = index $string_acc, $s;
    if ($index >= 0) {
      $saved += length($s);
      $strings_in_acc{$s} = $index;
    } else {
    OPTIMISER: {
    if ($opt{'O'}) {
      my $sublength = length $s;
      while (--$sublength > 0) {
        # progressively lop characters off the end, to see if the start of
        # the new string overlaps the end of the accumulator.
        if (substr ($string_acc, -$sublength)
        eq substr ($s, 0, $sublength)) {
          $subsave += $sublength;
          $strings_in_acc{$s} = length ($string_acc) - $sublength;
          # append the last bit on the end.
          $string_acc .= substr ($s, $sublength);
          last OPTIMISER;
        }
        # or if the end of the new string overlaps the start of the
        # accumulator
        next unless substr ($string_acc, 0, $sublength)
          eq substr ($s, -$sublength);
        # well, the last $sublength characters of the accumulator match.
        # so as we're prepending to the accumulator, need to shift all our
        # existing offsets forwards
        $_ += $sublength foreach values %strings_in_acc;
        $subsave += $sublength;
        $strings_in_acc{$s} = 0;
        # append the first bit on the start.
        $string_acc = substr ($s, 0, -$sublength) . $string_acc;
        last OPTIMISER;
      }
    }
    # Optimiser (if it ran) found nothing, so just going have to tack the
    # whole thing on the end.
    $strings_in_acc{$s} = length $string_acc;
    $string_acc .= $s;
      };
    }
  }

$strings = length $string_acc;
  my ($cpp) = compiler_info(0);
  my $var = $cpp ? '' : 'static';
  my $definition = "\n$var const U8 $name\[$strings] = { " .
    join(',',unpack "C*",$string_acc);
  # We have a single long line. Split it at convenient commas.
  print $fh $1, "\n" while $definition =~ /\G(.{74,77},)/gcs;
  print $fh substr ($definition, pos $definition), " };\n";
}

sub findstring {
  my ($name,$s) = @_;
  my $offset = $strings_in_acc{$s};
  die "Can't find string " . join (',',unpack "C*",$s) . " in accumulator"
    unless defined $offset;
  "$name + $offset";
}

sub outtable
{
 my ($fh,$a,$bigname) = @_;
 my $name = $a->{'Cname'};
 $a->{'Done'} = 1;
 foreach my $b (@{$a->{'Entries'}})
  {
   my ($s,$e,$out,$t,$end,$l) = @$b;
   outtable($fh,$t,$bigname) unless $t->{'Done'};
  }
 my ($cpp, $static) = compiler_info(0);
 my $count = scalar(@{$a->{'Entries'}});
 if ($static) {
     print $fh "#ifdef __cplusplus\n"; # -fpermissive since g++-6
     print $fh "encpage_t $name\[$count] = {\n";
     print $fh "#else\n";
     print $fh "static const encpage_t $name\[$count] = {\n";
     print $fh "#endif\n";
 } else {
   print $fh "\nencpage_t $name\[$count] = {\n";
 }
 foreach my $b (@{$a->{'Entries'}})
  {
   my ($sc,$ec,$out,$t,$end,$l,$fb) = @$b;
   # $end |= 0x80 if $fb; # what the heck was on your mind, Nick?  -- Dan
   print  $fh "{";
   if ($l)
    {
     printf $fh findstring($bigname,$out);
    }
   else
    {
     print  $fh "0";
    }
   print  $fh ",",$t->{Cname};
   printf $fh ",0x%02x,0x%02x,$l,$end},\n",$sc,$ec;
  }
 print $fh "};\n";
}

sub output_enc
{
 my ($fh,$name,$a) = @_;
 die "Changed - fix me for new structure";
 foreach my $b (sort keys %$a)
  {
   my ($s,$e,$out,$t,$end,$l,$fb) = @{$a->{$b}};
  }
}

sub decode_U
{
 my $s = shift;
}

my @uname;
sub char_names{} # cf. https://rt.cpan.org/Ticket/Display.html?id=132471

sub output_ucm_page
{
  my ($cmap,$a,$t,$pre) = @_;
  # warn sprintf("Page %x\n",$pre);
  my $raw = $t->{Raw};
  foreach my $key (sort keys %$raw) {
    #  RAW_NEXT => 0,
    #  RAW_IN_LEN => 1,
    #  RAW_OUT_BYTES => 2,
    #  RAW_FALLBACK => 3,
    my ($next, $in_len, $out_bytes, $fallback) = @{$raw->{$key}};
    my $u = ord $key;
    $fallback ||= 0;

if ($next != $a && $next != $t) {
      output_ucm_page($cmap,$a,$next,(($pre|($u &0x3F)) << 6)&0xFFFF);
    } elsif (length $out_bytes) {
      if ($pre) {
        $u = $pre|($u &0x3f);
      }
      my $s = sprintf "<U%04X> ",$u;
      #foreach my $c (split(//,$out_bytes)) {
      #  $s .= sprintf "\\x%02X",ord($c);
      #}
      # 9.5% faster changing that loop to this:
      $s .= sprintf +("\\x%02X" x length $out_bytes), unpack "C*", $out_bytes;
      $s .= sprintf " |%d # %s\n",($fallback ? 1 : 0),$uname[$u];
      push(@$cmap,$s);
    } else {
      warn join(',',$u, @{$raw->{$key}},$a,$t);
    }
  }
}

sub output_ucm
{
 my ($fh,$name,$h,$rep,$min_el,$max_el) = @_;
 print $fh "# $0 @orig_ARGV\n" unless $opt{'q'};
 print $fh "<code_set_name> \"$name\"\n";
 char_names();
 if (defined $min_el)
  {
   print $fh "<mb_cur_min> $min_el\n";
  }
 if (defined $max_el)
  {
   print $fh "<mb_cur_max> $max_el\n";
  }
 if (defined $rep)
  {
   print $fh "<subchar> ";
   foreach my $c (split(//,$rep))
    {
     printf $fh "\\x%02X",ord($c);
    }
   print $fh "\n";
  }
 my @cmap;
 output_ucm_page(\@cmap,$h,$h,0);
 print $fh "#\nCHARMAP\n";
 foreach my $line (sort { substr($a,8) cmp substr($b,8) } @cmap)
  {
   print $fh $line;
  }
 print $fh "END CHARMAP\n";
}

use vars qw(
    $_Enc2xs
    $_Version
    $_Inc
    $_E2X 
    $_Name
    $_TableFiles
    $_Now
);

sub find_e2x{
    eval { require File::Find; };
    my (@inc, %e2x_dir);
    for my $inc (@INC){
    push @inc, $inc unless $inc eq '.'; #skip current dir
    }
    File::Find::find(
         sub {
         my ($dev,$ino,$mode,$nlink,$uid,$gid,$rdev,$size,
             $atime,$mtime,$ctime,$blksize,$blocks)
             = lstat($_) or return;
         -f _ or return;
         if (/^.*\.e2x$/o){
             no warnings 'once';
             $e2x_dir{$File::Find::dir} ||= $mtime;
         }
         return;
         }, @inc);
    warn join("\n", keys %e2x_dir), "\n";
    for my $d (sort {$e2x_dir{$a} <=> $e2x_dir{$b}} keys %e2x_dir){
    $_E2X = $d;
    # warn "$_E2X => ", scalar localtime($e2x_dir{$d});
    return $_E2X;
    }
}

sub make_makefile_pl
{
    eval { require Encode } or die "You need to install Encode to use enc2xs -M\nerror: $@\n";
    # our used for variable expansion
    $_Enc2xs = $0;
    $_Version = $VERSION;
    $_E2X = find_e2x();
    $_Name = shift;
    $_TableFiles = join(",", map {qq('$_')} @_);
    $_Now = scalar localtime();

eval { require File::Spec; };
    _print_expand(File::Spec->catfile($_E2X,"Makefile_PL.e2x"),"Makefile.PL");
    _print_expand(File::Spec->catfile($_E2X,"_PM.e2x"),        "$_Name.pm");
    _print_expand(File::Spec->catfile($_E2X,"_T.e2x"),         "t/$_Name.t");
    _print_expand(File::Spec->catfile($_E2X,"README.e2x"),     "README");
    _print_expand(File::Spec->catfile($_E2X,"Changes.e2x"),    "Changes");
    exit;
}

use vars qw(
        $_ModLines
        $_LocalVer
        );

sub make_configlocal_pm {
    eval { require Encode } or die "Unable to require Encode: $@\n";
    eval { require File::Spec; };

# our used for variable expantion
    my %in_core = map { $_ => 1 } (
        'ascii',      'iso-8859-1', 'utf8',
        'ascii-ctrl', 'null',       'utf-8-strict'
    );
    my %LocalMod = ();
    # check @enc;
    use File::Find ();
    my $wanted = sub{
	-f $_ or return;
	$File::Find::name =~ /\A\./        and return;
	$File::Find::name =~ /\.pm\z/      or  return;
	$File::Find::name =~ m/\bEncode\b/ or  return;
	my $mod = $File::Find::name;
	$mod =~ s/.*\bEncode\b/Encode/o;
	$mod =~ s/\.pm\z//o;
	$mod =~ s,/,::,og;
	eval qq{ require $mod; } or return;
        warn qq{ require $mod;\n};
	for my $enc ( Encode->encodings() ) {
	    no warnings;
	    $in_core{$enc}                   and next;
	    $Encode::Config::ExtModule{$enc} and next;
	    $LocalMod{$enc} ||= $mod;
	}
    };
    File::Find::find({wanted => $wanted}, @INC);
    $_ModLines = "";
    for my $enc ( sort keys %LocalMod ) {
        $_ModLines .=
          qq(\$Encode::ExtModule{'$enc'} = "$LocalMod{$enc}";\n);
    }
    warn $_ModLines if $_ModLines;
    $_LocalVer = _mkversion();
    $_E2X      = find_e2x();
    $_Inc      = $INC{"Encode.pm"};
    $_Inc =~ s/\.pm$//o;
    _print_expand( File::Spec->catfile( $_E2X, "ConfigLocal_PM.e2x" ),
        File::Spec->catfile( $_Inc, "ConfigLocal.pm" ), 1 );
    exit;
}

sub _mkversion{
    # v-string is now depreciated; use time() instead;
    #my ($ss,$mm,$hh,$dd,$mo,$yyyy) = localtime();
    #$yyyy += 1900, $mo +=1;
    #return sprintf("v%04d.%04d.%04d", $yyyy, $mo*100+$dd, $hh*100+$mm);
    return time();
}

sub _print_expand{
    eval { require File::Basename } or die "File::Basename needed.  Are you on miniperl?;\nerror: $@\n";
    File::Basename->import();
    my ($src, $dst, $clobber) = @_;
    if (!$clobber and -e $dst){
    warn "$dst exists. skipping\n";
    return;
    }
    warn "Generating $dst...\n";
    open my $in, $src or die "$src : $!";
    if ((my $d = dirname($dst)) ne '.'){
    -d $d or mkdir $d, 0755 or die  "mkdir $d : $!";
    }	   
    open my $out, ">", $dst or die "$!";
    my $asis = 0;
    while (<$in>){ 
    if (/^#### END_OF_HEADER/){
        $asis = 1; next;
    }	  
    s/(\$_[A-Z][A-Za-z0-9]+)_/$1/gee unless $asis;
    print $out $_;
    }
}
__END__

=head1 NAME

enc2xs -- Perl Encode Module Generator

=head1 SYNOPSIS

enc2xs -[options]
  enc2xs -M ModName mapfiles...
  enc2xs -C

=head1 DESCRIPTION

F<enc2xs> builds a Perl extension for use by Encode from either
Unicode Character Mapping files (.ucm) or Tcl Encoding Files (.enc).
Besides being used internally during the build process of the Encode
module, you can use F<enc2xs> to add your own encoding to perl.
No knowledge of XS is necessary.

=head1 Quick Guide

If you want to know as little about Perl as possible but need to
add a new encoding, just read this chapter and forget the rest.

=over 4

=item 0.Z<>

Have a .ucm file ready.  You can get it from somewhere or you can write
your own from scratch or you can grab one from the Encode distribution
and customize it.  For the UCM format, see the next Chapter.  In the
example below, I'll call my theoretical encoding myascii, defined
in I<my.ucm>.  C<$> is a shell prompt.

$ ls -F
  my.ucm

=item 1.Z<>

Issue a command as follows;

$ enc2xs -M My my.ucm
  generating Makefile.PL
  generating My.pm
  generating README
  generating Changes

Now take a look at your current directory.  It should look like this.

$ ls -F
  Makefile.PL   My.pm         my.ucm        t/

The following files were created.

Makefile.PL - MakeMaker script
  My.pm       - Encode submodule
  t/My.t      - test file

=over 4

=item 1.1.Z<>

If you want *.ucm installed together with the modules, do as follows;

$ mkdir Encode
  $ mv *.ucm Encode
  $ enc2xs -M My Encode/*ucm

=back

=item 2.Z<>

Edit the files generated.  You don't have to if you have no time AND no
intention to give it to someone else.  But it is a good idea to edit
the pod and to add more tests.

=item 3.Z<>

Now issue a command all Perl Mongers love:

$ perl Makefile.PL
  Writing Makefile for Encode::My

=item 4.Z<>

Now all you have to do is make.

$ make
  cp My.pm blib/lib/Encode/My.pm
  /usr/local/bin/perl /usr/local/bin/enc2xs -Q -O \
    -o encode_t.c -f encode_t.fnm
  Reading myascii (myascii)
  Writing compiled form
  128 bytes in string tables
  384 bytes (75%) saved spotting duplicates
  1 bytes (0.775%) saved using substrings
  ....
  chmod 644 blib/arch/auto/Encode/My/My.bs
  $

The time it takes varies depending on how fast your machine is and
how large your encoding is.  Unless you are working on something big
like euc-tw, it won't take too long.

=item 5.Z<>

You can "make install" already but you should test first.

$ make test
  PERL_DL_NONLAZY=1 /usr/local/bin/perl -Iblib/arch -Iblib/lib \
    -e 'use Test::Harness  qw(&runtests $verbose); \
    $verbose=0; runtests @ARGV;' t/*.t
  t/My....ok
  All tests successful.
  Files=1, Tests=2,  0 wallclock secs
   ( 0.09 cusr + 0.01 csys = 0.09 CPU)

=item 6.Z<>

If you are content with the test result, just "make install"

=item 7.Z<>

If you want to add your encoding to Encode's demand-loading list
(so you don't have to "use Encode::YourEncoding"), run

enc2xs -C

to update Encode::ConfigLocal, a module that controls local settings.
After that, "use Encode;" is enough to load your encodings on demand.

=back

=head1 The Unicode Character Map

Encode uses the Unicode Character Map (UCM) format for source character
mappings.  This format is used by IBM's ICU package and was adopted
by Nick Ing-Simmons for use with the Encode module.  Since UCM is
more flexible than Tcl's Encoding Map and far more user-friendly,
this is the recommended format for Encode now.

A UCM file looks like this.

#
  # Comments
  #
  <code_set_name> "US-ascii" # Required
  <code_set_alias> "ascii"   # Optional
  <mb_cur_min> 1             # Required; usually 1
  <mb_cur_max> 1             # Max. # of bytes/char
  <subchar> \x3F             # Substitution char
  #
  CHARMAP
  <U0000> \x00 |0 # <control>
  <U0001> \x01 |0 # <control>
  <U0002> \x02 |0 # <control>
  ....
  <U007C> \x7C |0 # VERTICAL LINE
  <U007D> \x7D |0 # RIGHT CURLY BRACKET
  <U007E> \x7E |0 # TILDE
  <U007F> \x7F |0 # <control>
  END CHARMAP

=over 4

=item *

Anything that follows C<#> is treated as a comment.

=item *

The header section continues until a line containing the word
CHARMAP. This section has a form of I<E<lt>keywordE<gt> value>, one
pair per line.  Strings used as values must be quoted. Barewords are
treated as numbers.  I<\xXX> represents a byte.

Most of the keywords are self-explanatory. I<subchar> means
substitution character, not subcharacter.  When you decode a Unicode
sequence to this encoding but no matching character is found, the byte
sequence defined here will be used.  For most cases, the value here is
\x3F; in ASCII, this is a question mark.

=item *

CHARMAP starts the character map section.  Each line has a form as
follows:

<UXXXX> \xXX.. |0 # comment
    ^     ^      ^
    |     |      +- Fallback flag
    |     +-------- Encoded byte sequence
    +-------------- Unicode Character ID in hex

The format is roughly the same as a header section except for the
fallback flag: | followed by 0..3.   The meaning of the possible
values is as follows:

=over 4

=item |0

Round trip safe.  A character decoded to Unicode encodes back to the
same byte sequence.  Most characters have this flag.

=item |1

Fallback for unicode -> encoding.  When seen, enc2xs adds this
character for the encode map only.

=item |2

Skip sub-char mapping should there be no code point.

=item |3

Fallback for encoding -> unicode.  When seen, enc2xs adds this
character for the decode map only.

=back

=item *

And finally, END OF CHARMAP ends the section.

=back

When you are manually creating a UCM file, you should copy ascii.ucm
or an existing encoding which is close to yours, rather than write
your own from scratch.

When you do so, make sure you leave at least B<U0000> to B<U0020> as
is, unless your environment is EBCDIC.

B<CAVEAT>: not all features in UCM are implemented.  For example,
icu:state is not used.  Because of that, you need to write a perl
module if you want to support algorithmical encodings, notably
the ISO-2022 series.  Such modules include L<Encode::JP::2022_JP>,
L<Encode::KR::2022_KR>, and L<Encode::TW::HZ>.

=head2 Coping with duplicate mappings

When you create a map, you SHOULD make your mappings round-trip safe.
That is, C<encode('your-encoding', decode('your-encoding', $data)) eq
$data> stands for all characters that are marked as C<|0>.  Here is
how to make sure:

=over 4

=item *

Sort your map in Unicode order.

=item *

When you have a duplicate entry, mark either one with '|1' or '|3'.
  
=item *

And make sure the '|1' or '|3' entry FOLLOWS the '|0' entry.

=back

Here is an example from big5-eten.

<U2550> \xF9\xF9 |0
  <U2550> \xA2\xA4 |3

Internally Encoding -> Unicode and Unicode -> Encoding Map looks like
this;

E to U               U to E
  --------------------------------------
  \xF9\xF9 => U2550    U2550 => \xF9\xF9
  \xA2\xA4 => U2550
 
So it is round-trip safe for \xF9\xF9.  But if the line above is upside
down, here is what happens.

E to U               U to E
  --------------------------------------
  \xA2\xA4 => U2550    U2550 => \xF9\xF9
  (\xF9\xF9 => U2550 is now overwritten!)

The Encode package comes with F<ucmlint>, a crude but sufficient
utility to check the integrity of a UCM file.  Check under the
Encode/bin directory for this.

When in doubt, you can use F<ucmsort>, yet another utility under
Encode/bin directory.

=head1 Bookmarks

=over 4

=item *

ICU Home Page 
L<http://www.icu-project.org/>

=item *

ICU Character Mapping Tables
L<http://site.icu-project.org/charts/charset>

=item *

ICU:Conversion Data
L<http://www.icu-project.org/userguide/conversion-data.html>

=back

=head1 SEE ALSO

L<Encode>,
L<perlmod>,
L<perlpod>

=cut

# -Q to disable the duplicate codepoint test
# -S make mapping errors fatal
# -q to remove comments written to output files
# -O to enable the (brute force) substring optimiser
# -o <output> to specify the output file name (else it's the first arg)
# -f <inlist> to give a file with a list of input files (else use the args)
# -n <name> to name the encoding (else use the basename of the input file.

With %seen holding array refs:

865.66 real        28.80 user         8.79 sys
      7904  maximum resident set size
      1356  average shared memory size
     18566  average unshared data size
       229  average unshared stack size
     46080  page reclaims
     33373  page faults

With %seen holding simple scalars:

342.16 real        27.11 user         3.54 sys
      8388  maximum resident set size
      1394  average shared memory size
     14969  average unshared data size
       236  average unshared stack size
     28159  page reclaims
      9839  page faults

Yes, 5 minutes is faster than 15. Above is for CP936 in CN. Only difference is
how %seen is storing things its seen. So it is pathalogically bad on a 16M
RAM machine, but it's going to help even on modern machines.
Swapping is bad, m'kay :-)